notify-api-412 use black to enforce python coding style

app/notify_client/service_api_client.py

@@ -7,7 +7,7 @@ from app.notify_client import NotifyAdminAPIClient, _attach_current_user, cache
 
 
 class ServiceAPIClient(NotifyAdminAPIClient):
-    @cache.delete('user-{user_id}')
+    @cache.delete("user-{user_id}")
     def create_service(
         self,
         service_name,
@@ -30,97 +30,100 @@ class ServiceAPIClient(NotifyAdminAPIClient):
             "email_from": email_from,
         }
         data = _attach_current_user(data)
-        return self.post("/service", data)['data']['id']
+        return self.post("/service", data)["data"]["id"]
 
-    @cache.set('service-{service_id}')
+    @cache.set("service-{service_id}")
     def get_service(self, service_id):
         """
         Retrieve a service.
         """
-        return self.get('/service/{0}'.format(service_id))
+        return self.get("/service/{0}".format(service_id))
 
     def get_service_statistics(self, service_id, limit_days=None):
-        return self.get('/service/{0}/statistics'.format(service_id), params={'limit_days': limit_days})['data']
+        return self.get(
+            "/service/{0}/statistics".format(service_id),
+            params={"limit_days": limit_days},
+        )["data"]
 
     def get_services(self, params_dict=None):
         """
         Retrieve a list of services.
         """
-        return self.get('/service', params=params_dict)
+        return self.get("/service", params=params_dict)
 
     def find_services_by_name(self, service_name):
-        return self.get('/service/find-services-by-name', params={"service_name": service_name})
+        return self.get(
+            "/service/find-services-by-name", params={"service_name": service_name}
+        )
 
     def get_live_services_data(self, params_dict=None):
         """
         Retrieve a list of live services data with contact names and notification counts.
         """
-        return self.get('/service/live-services-data', params=params_dict)
+        return self.get("/service/live-services-data", params=params_dict)
 
     def get_active_services(self, params_dict=None):
         """
         Retrieve a list of active services.
         """
-        params_dict['only_active'] = True
+        params_dict["only_active"] = True
         return self.get_services(params_dict)
 
-    @cache.delete('service-{service_id}')
-    def update_service(
-        self,
-        service_id,
-        **kwargs
-    ):
+    @cache.delete("service-{service_id}")
+    def update_service(self, service_id, **kwargs):
         """
         Update a service.
         """
         data = _attach_current_user(kwargs)
         disallowed_attributes = set(data.keys()) - {
-            'active',
-            'billing_contact_email_addresses',
-            'billing_contact_names',
-            'billing_reference',
-            'consent_to_research',
-            'contact_link',
-            'created_by',
-            'count_as_live',
-            'email_branding',
-            'email_from',
-            'free_sms_fragment_limit',
-            'go_live_at',
-            'go_live_user',
-            'message_limit',
-            'name',
-            'notes',
-            'organization_type',
-            'permissions',
-            'prefix_sms',
-            'purchase_order_number',
-            'rate_limit',
-            'reply_to_email_address',
-            'research_mode',
-            'restricted',
-            'sms_sender',
-            'volume_email',
-            'volume_sms',
+            "active",
+            "billing_contact_email_addresses",
+            "billing_contact_names",
+            "billing_reference",
+            "consent_to_research",
+            "contact_link",
+            "created_by",
+            "count_as_live",
+            "email_branding",
+            "email_from",
+            "free_sms_fragment_limit",
+            "go_live_at",
+            "go_live_user",
+            "message_limit",
+            "name",
+            "notes",
+            "organization_type",
+            "permissions",
+            "prefix_sms",
+            "purchase_order_number",
+            "rate_limit",
+            "reply_to_email_address",
+            "research_mode",
+            "restricted",
+            "sms_sender",
+            "volume_email",
+            "volume_sms",
         }
         if disallowed_attributes:
-            raise TypeError('Not allowed to update service attributes: {}'.format(
-                ", ".join(disallowed_attributes)
-            ))
+            raise TypeError(
+                "Not allowed to update service attributes: {}".format(
+                    ", ".join(disallowed_attributes)
+                )
+            )
 
         endpoint = "/service/{0}".format(service_id)
         return self.post(endpoint, data)
 
-    @cache.delete('live-service-and-organization-counts')
+    @cache.delete("live-service-and-organization-counts")
     def update_status(self, service_id, live):
         return self.update_service(
             service_id,
             message_limit=250000 if live else 50,
             restricted=(not live),
-            go_live_at=str(datetime.utcnow()) if live else None
+            go_live_at=str(datetime.utcnow()) if live else None,
         )
 
-    @cache.delete('live-service-and-organization-counts')
+    @cache.delete("live-service-and-organization-counts")
     def update_count_as_live(self, service_id, count_as_live):
         return self.update_service(
             service_id,
@@ -131,37 +134,38 @@ class ServiceAPIClient(NotifyAdminAPIClient):
     def update_service_with_properties(self, service_id, properties):
         return self.update_service(service_id, **properties)
 
-    @cache.delete('service-{service_id}')
-    @cache.delete('service-{service_id}-templates')
-    @cache.delete_by_pattern('service-{service_id}-template-*')
+    @cache.delete("service-{service_id}")
+    @cache.delete("service-{service_id}-templates")
+    @cache.delete_by_pattern("service-{service_id}-template-*")
     def archive_service(self, service_id, cached_service_user_ids):
         if cached_service_user_ids:
-            redis_client.delete(*map('user-{}'.format, cached_service_user_ids))
-        return self.post('/service/{}/archive'.format(service_id), data=None)
+            redis_client.delete(*map("user-{}".format, cached_service_user_ids))
+        return self.post("/service/{}/archive".format(service_id), data=None)
 
-    @cache.delete('service-{service_id}')
+    @cache.delete("service-{service_id}")
     def suspend_service(self, service_id):
-        return self.post('/service/{}/suspend'.format(service_id), data=None)
+        return self.post("/service/{}/suspend".format(service_id), data=None)
 
-    @cache.delete('service-{service_id}')
+    @cache.delete("service-{service_id}")
     def resume_service(self, service_id):
-        return self.post('/service/{}/resume'.format(service_id), data=None)
+        return self.post("/service/{}/resume".format(service_id), data=None)
 
-    @cache.delete('service-{service_id}')
-    @cache.delete('user-{user_id}')
+    @cache.delete("service-{service_id}")
+    @cache.delete("user-{user_id}")
     def remove_user_from_service(self, service_id, user_id):
         """
         Remove a user from a service
         """
-        endpoint = '/service/{service_id}/users/{user_id}'.format(
-            service_id=service_id,
-            user_id=user_id)
+        endpoint = "/service/{service_id}/users/{user_id}".format(
+            service_id=service_id, user_id=user_id
+        )
         data = _attach_current_user({})
         return self.delete(endpoint, data)
 
-    @cache.delete('service-{service_id}-templates')
-    def create_service_template(self, name, type_, content, service_id, subject=None,
-                                parent_folder_id=None):
+    @cache.delete("service-{service_id}-templates")
+    def create_service_template(
+        self, name, type_, content, service_id, subject=None, parent_folder_id=None
+    ):
         """
         Create a service template.
         """
@@ -170,22 +174,18 @@ class ServiceAPIClient(NotifyAdminAPIClient):
             "template_type": type_,
             "content": content,
             "service": service_id,
-            "process_type": 'normal',
+            "process_type": "normal",
         }
         if subject:
-            data.update({
-                'subject': subject
-            })
+            data.update({"subject": subject})
         if parent_folder_id:
-            data.update({
-                'parent_folder_id': parent_folder_id
-            })
+            data.update({"parent_folder_id": parent_folder_id})
         data = _attach_current_user(data)
         endpoint = "/service/{0}/template".format(service_id)
         return self.post(endpoint, data)
 
-    @cache.delete('service-{service_id}-templates')
-    @cache.delete_by_pattern('service-{service_id}-template-*')
+    @cache.delete("service-{service_id}-templates")
+    @cache.delete_by_pattern("service-{service_id}-template-*")
     def update_service_template(
         self, id_, name, type_, content, service_id, subject=None
     ):
@@ -193,65 +193,57 @@ class ServiceAPIClient(NotifyAdminAPIClient):
         Update a service template.
         """
         data = {
-            'id': id_,
-            'name': name,
-            'template_type': type_,
-            'content': content,
-            'service': service_id
+            "id": id_,
+            "name": name,
+            "template_type": type_,
+            "content": content,
+            "service": service_id,
         }
         if subject:
-            data.update({
-                'subject': subject
-            })
-        data.update({
-            'process_type': 'normal'
-        })
+            data.update({"subject": subject})
+        data.update({"process_type": "normal"})
         data = _attach_current_user(data)
         endpoint = "/service/{0}/template/{1}".format(service_id, id_)
         return self.post(endpoint, data)
 
-    @cache.delete('service-{service_id}-templates')
-    @cache.delete_by_pattern('service-{service_id}-template-*')
+    @cache.delete("service-{service_id}-templates")
+    @cache.delete_by_pattern("service-{service_id}-template-*")
     def redact_service_template(self, service_id, id_):
         return self.post(
             "/service/{}/template/{}".format(service_id, id_),
-            _attach_current_user(
-                {'redact_personalisation': True}
-            ),
+            _attach_current_user({"redact_personalisation": True}),
         )
 
-    @cache.delete('service-{service_id}-templates')
-    @cache.delete_by_pattern('service-{service_id}-template-*')
+    @cache.delete("service-{service_id}-templates")
+    @cache.delete_by_pattern("service-{service_id}-template-*")
     def update_service_template_sender(self, service_id, template_id, reply_to):
         data = {
-            'reply_to': reply_to,
+            "reply_to": reply_to,
         }
         data = _attach_current_user(data)
         return self.post(
-            "/service/{0}/template/{1}".format(service_id, template_id),
-            data
+            "/service/{0}/template/{1}".format(service_id, template_id), data
         )
 
-    @cache.set('service-{service_id}-template-{template_id}-version-{version}')
+    @cache.set("service-{service_id}-template-{template_id}-version-{version}")
     def get_service_template(self, service_id, template_id, version=None):
         """
         Retrieve a service template.
         """
-        endpoint = '/service/{service_id}/template/{template_id}'.format(
-            service_id=service_id,
-            template_id=template_id)
+        endpoint = "/service/{service_id}/template/{template_id}".format(
+            service_id=service_id, template_id=template_id
+        )
         if version:
-            endpoint = '{base}/version/{version}'.format(base=endpoint, version=version)
+            endpoint = "{base}/version/{version}".format(base=endpoint, version=version)
         return self.get(endpoint)
 
-    @cache.set('service-{service_id}-template-{template_id}-versions')
+    @cache.set("service-{service_id}-template-{template_id}-versions")
     def get_service_template_versions(self, service_id, template_id):
         """
         Retrieve a list of versions for a template
         """
-        endpoint = '/service/{service_id}/template/{template_id}/versions'.format(
-            service_id=service_id,
-            template_id=template_id
+        endpoint = "/service/{service_id}/template/{template_id}/versions".format(
+            service_id=service_id, template_id=template_id
         )
         return self.get(endpoint)
 
@@ -259,268 +251,244 @@ class ServiceAPIClient(NotifyAdminAPIClient):
         """
         Returns the precompiled template for a service, creating it if it doesn't already exist
         """
-        return self.get('/service/{}/template/precompiled'.format(service_id))
+        return self.get("/service/{}/template/precompiled".format(service_id))
 
-    @cache.set('service-{service_id}-templates')
+    @cache.set("service-{service_id}-templates")
     def get_service_templates(self, service_id):
         """
         Retrieve all templates for service.
         """
-        endpoint = '/service/{service_id}/template?detailed=False'.format(
-            service_id=service_id)
+        endpoint = "/service/{service_id}/template?detailed=False".format(
+            service_id=service_id
+        )
         return self.get(endpoint)
 
     # This doesn’t need caching because it calls through to a method which is cached
     def count_service_templates(self, service_id, template_type=None):
-        return len([
-            template for template in
-            self.get_service_templates(service_id)['data']
-            if (
-                not template_type
-                or template['template_type'] == template_type
-            )
-        ])
+        return len(
+            [
+                template
+                for template in self.get_service_templates(service_id)["data"]
+                if (not template_type or template["template_type"] == template_type)
+            ]
+        )
 
-    @cache.delete('service-{service_id}-templates')
-    @cache.delete_by_pattern('service-{service_id}-template-*')
+    @cache.delete("service-{service_id}-templates")
+    @cache.delete_by_pattern("service-{service_id}-template-*")
     def delete_service_template(self, service_id, template_id):
         """
         Set a service template's archived flag to True
         """
         endpoint = "/service/{0}/template/{1}".format(service_id, template_id)
-        data = {
-            'archived': True
-        }
+        data = {"archived": True}
         data = _attach_current_user(data)
         return self.post(endpoint, data=data)
 
     # Temp access of service history data. Includes service and api key history
     def get_service_history(self, service_id):
-        return self.get('/service/{0}/history'.format(service_id))['data']
+        return self.get("/service/{0}/history".format(service_id))["data"]
 
     def get_service_service_history(self, service_id):
-        return self.get_service_history(service_id)['service_history']
+        return self.get_service_history(service_id)["service_history"]
 
     def get_service_api_key_history(self, service_id):
-        return self.get_service_history(service_id)['api_key_history']
+        return self.get_service_history(service_id)["api_key_history"]
 
     def get_monthly_notification_stats(self, service_id, year):
-        return self.get(url='/service/{}/notifications/monthly?year={}'.format(service_id, year))
+        return self.get(
+            url="/service/{}/notifications/monthly?year={}".format(service_id, year)
+        )
 
     def get_guest_list(self, service_id):
-        return self.get(url='/service/{}/guest-list'.format(service_id))
+        return self.get(url="/service/{}/guest-list".format(service_id))
 
-    @cache.delete('service-{service_id}')
+    @cache.delete("service-{service_id}")
     def update_guest_list(self, service_id, data):
-        return self.put(url='/service/{}/guest-list'.format(service_id), data=data)
+        return self.put(url="/service/{}/guest-list".format(service_id), data=data)
 
-    def get_inbound_sms(self, service_id, user_number=''):
+    def get_inbound_sms(self, service_id, user_number=""):
         # POST prevents the user phone number leaking into our logs
         return self.post(
-            '/service/{}/inbound-sms'.format(
+            "/service/{}/inbound-sms".format(
                 service_id,
             ),
-            data={'phone_number': user_number}
+            data={"phone_number": user_number},
         )
 
     def get_most_recent_inbound_sms(self, service_id, page=None):
         return self.get(
-            '/service/{}/inbound-sms/most-recent'.format(
+            "/service/{}/inbound-sms/most-recent".format(
                 service_id,
             ),
-            params={
-                'page': page
-            }
+            params={"page": page},
         )
 
     def get_inbound_sms_by_id(self, service_id, notification_id):
         return self.get(
-            '/service/{}/inbound-sms/{}'.format(
+            "/service/{}/inbound-sms/{}".format(
                 service_id,
                 notification_id,
             )
         )
 
     def get_inbound_sms_summary(self, service_id):
-        return self.get(
-            '/service/{}/inbound-sms/summary'.format(service_id)
-        )
+        return self.get("/service/{}/inbound-sms/summary".format(service_id))
 
-    @cache.delete('service-{service_id}')
+    @cache.delete("service-{service_id}")
     def create_service_inbound_api(self, service_id, url, bearer_token, user_id):
-        data = {
-            "url": url,
-            "bearer_token": bearer_token,
-            "updated_by_id": user_id
-        }
+        data = {"url": url, "bearer_token": bearer_token, "updated_by_id": user_id}
         return self.post("/service/{}/inbound-api".format(service_id), data)
 
-    @cache.delete('service-{service_id}')
-    def update_service_inbound_api(self, service_id, url, bearer_token, user_id, inbound_api_id):
-        data = {
-            "url": url,
-            "updated_by_id": user_id
-        }
+    @cache.delete("service-{service_id}")
+    def update_service_inbound_api(
+        self, service_id, url, bearer_token, user_id, inbound_api_id
+    ):
+        data = {"url": url, "updated_by_id": user_id}
         if bearer_token:
-            data['bearer_token'] = bearer_token
-        return self.post("/service/{}/inbound-api/{}".format(service_id, inbound_api_id), data)
+            data["bearer_token"] = bearer_token
+        return self.post(
+            "/service/{}/inbound-api/{}".format(service_id, inbound_api_id), data
+        )
 
     def get_service_inbound_api(self, service_id, inbound_sms_api_id):
         return self.get(
-            "/service/{}/inbound-api/{}".format(
-                service_id, inbound_sms_api_id
-            )
-        )['data']
+            "/service/{}/inbound-api/{}".format(service_id, inbound_sms_api_id)
+        )["data"]
 
-    @cache.delete('service-{service_id}')
+    @cache.delete("service-{service_id}")
     def delete_service_inbound_api(self, service_id, callback_api_id):
-        return self.delete("/service/{}/inbound-api/{}".format(
-            service_id, callback_api_id
-        ))
+        return self.delete(
+            "/service/{}/inbound-api/{}".format(service_id, callback_api_id)
+        )
 
     def get_reply_to_email_addresses(self, service_id):
-        return self.get(
-            "/service/{}/email-reply-to".format(
-                service_id
-            )
-        )
+        return self.get("/service/{}/email-reply-to".format(service_id))
 
     def get_reply_to_email_address(self, service_id, reply_to_email_id):
         return self.get(
-            "/service/{}/email-reply-to/{}".format(
-                service_id,
-                reply_to_email_id
-            )
+            "/service/{}/email-reply-to/{}".format(service_id, reply_to_email_id)
         )
 
     def verify_reply_to_email_address(self, service_id, email_address):
         return self.post(
             "/service/{}/email-reply-to/verify".format(service_id),
-            data={"email": email_address}
+            data={"email": email_address},
         )
 
-    @cache.delete('service-{service_id}')
-    @cache.delete_by_pattern('service-{service_id}-template-*')
+    @cache.delete("service-{service_id}")
+    @cache.delete_by_pattern("service-{service_id}-template-*")
     def add_reply_to_email_address(self, service_id, email_address, is_default=False):
         return self.post(
             "/service/{}/email-reply-to".format(service_id),
-            data={
-                "email_address": email_address,
-                "is_default": is_default
-            }
+            data={"email_address": email_address, "is_default": is_default},
         )
 
-    @cache.delete('service-{service_id}')
-    @cache.delete_by_pattern('service-{service_id}-template-*')
-    def update_reply_to_email_address(self, service_id, reply_to_email_id, email_address, is_default=False):
+    @cache.delete("service-{service_id}")
+    @cache.delete_by_pattern("service-{service_id}-template-*")
+    def update_reply_to_email_address(
+        self, service_id, reply_to_email_id, email_address, is_default=False
+    ):
         return self.post(
             "/service/{}/email-reply-to/{}".format(
                 service_id,
                 reply_to_email_id,
             ),
-            data={
-                "email_address": email_address,
-                "is_default": is_default
-            }
+            data={"email_address": email_address, "is_default": is_default},
         )
 
-    @cache.delete('service-{service_id}')
-    @cache.delete_by_pattern('service-{service_id}-template-*')
+    @cache.delete("service-{service_id}")
+    @cache.delete_by_pattern("service-{service_id}-template-*")
     def delete_reply_to_email_address(self, service_id, reply_to_email_id):
         return self.post(
-            "/service/{}/email-reply-to/{}/archive".format(service_id, reply_to_email_id),
-            data=None
+            "/service/{}/email-reply-to/{}/archive".format(
+                service_id, reply_to_email_id
+            ),
+            data=None,
         )
 
     def get_sms_senders(self, service_id):
-        return self.get(
-            "/service/{}/sms-sender".format(service_id)
-        )
+        return self.get("/service/{}/sms-sender".format(service_id))
 
     def get_sms_sender(self, service_id, sms_sender_id):
-        return self.get(
-            "/service/{}/sms-sender/{}".format(service_id, sms_sender_id)
-        )
+        return self.get("/service/{}/sms-sender/{}".format(service_id, sms_sender_id))
 
-    @cache.delete('service-{service_id}')
-    @cache.delete_by_pattern('service-{service_id}-template-*')
-    def add_sms_sender(self, service_id, sms_sender, is_default=False, inbound_number_id=None):
-        data = {
-            "sms_sender": sms_sender,
-            "is_default": is_default
-        }
+    @cache.delete("service-{service_id}")
+    @cache.delete_by_pattern("service-{service_id}-template-*")
+    def add_sms_sender(
+        self, service_id, sms_sender, is_default=False, inbound_number_id=None
+    ):
+        data = {"sms_sender": sms_sender, "is_default": is_default}
         if inbound_number_id:
             data["inbound_number_id"] = inbound_number_id
         return self.post("/service/{}/sms-sender".format(service_id), data=data)
 
-    @cache.delete('service-{service_id}')
-    @cache.delete_by_pattern('service-{service_id}-template-*')
-    def update_sms_sender(self, service_id, sms_sender_id, sms_sender, is_default=False):
+    @cache.delete("service-{service_id}")
+    @cache.delete_by_pattern("service-{service_id}-template-*")
+    def update_sms_sender(
+        self, service_id, sms_sender_id, sms_sender, is_default=False
+    ):
         return self.post(
             "/service/{}/sms-sender/{}".format(service_id, sms_sender_id),
-            data={
-                "sms_sender": sms_sender,
-                "is_default": is_default
-            }
+            data={"sms_sender": sms_sender, "is_default": is_default},
         )
 
-    @cache.delete('service-{service_id}')
-    @cache.delete_by_pattern('service-{service_id}-template-*')
+    @cache.delete("service-{service_id}")
+    @cache.delete_by_pattern("service-{service_id}-template-*")
     def delete_sms_sender(self, service_id, sms_sender_id):
         return self.post(
             "/service/{}/sms-sender/{}/archive".format(service_id, sms_sender_id),
-            data=None
+            data=None,
         )
 
     def get_service_callback_api(self, service_id, callback_api_id):
         return self.get(
-            "/service/{}/delivery-receipt-api/{}".format(
-                service_id, callback_api_id
-            )
-        )['data']
+            "/service/{}/delivery-receipt-api/{}".format(service_id, callback_api_id)
+        )["data"]
 
-    @cache.delete('service-{service_id}')
-    def update_service_callback_api(self, service_id, url, bearer_token, user_id, callback_api_id):
-        data = {
-            "url": url,
-            "updated_by_id": user_id
-        }
+    @cache.delete("service-{service_id}")
+    def update_service_callback_api(
+        self, service_id, url, bearer_token, user_id, callback_api_id
+    ):
+        data = {"url": url, "updated_by_id": user_id}
         if bearer_token:
-            data['bearer_token'] = bearer_token
-        return self.post("/service/{}/delivery-receipt-api/{}".format(service_id, callback_api_id), data)
+            data["bearer_token"] = bearer_token
+        return self.post(
+            "/service/{}/delivery-receipt-api/{}".format(service_id, callback_api_id),
+            data,
+        )
 
-    @cache.delete('service-{service_id}')
+    @cache.delete("service-{service_id}")
     def delete_service_callback_api(self, service_id, callback_api_id):
-        return self.delete("/service/{}/delivery-receipt-api/{}".format(
-            service_id, callback_api_id
-        ))
+        return self.delete(
+            "/service/{}/delivery-receipt-api/{}".format(service_id, callback_api_id)
+        )
 
-    @cache.delete('service-{service_id}')
+    @cache.delete("service-{service_id}")
     def create_service_callback_api(self, service_id, url, bearer_token, user_id):
-        data = {
-            "url": url,
-            "bearer_token": bearer_token,
-            "updated_by_id": user_id
-        }
+        data = {"url": url, "bearer_token": bearer_token, "updated_by_id": user_id}
         return self.post("/service/{}/delivery-receipt-api".format(service_id), data)
 
-    @cache.delete('service-{service_id}-data-retention')
-    def create_service_data_retention(self, service_id, notification_type, days_of_retention):
+    @cache.delete("service-{service_id}-data-retention")
+    def create_service_data_retention(
+        self, service_id, notification_type, days_of_retention
+    ):
         data = {
             "notification_type": notification_type,
-            "days_of_retention": days_of_retention
+            "days_of_retention": days_of_retention,
         }
 
         return self.post("/service/{}/data-retention".format(service_id), data)
 
-    @cache.delete('service-{service_id}-data-retention')
-    def update_service_data_retention(self, service_id, data_retention_id, days_of_retention):
-        data = {
-            "days_of_retention": days_of_retention
-        }
-        return self.post("/service/{}/data-retention/{}".format(service_id, data_retention_id), data)
+    @cache.delete("service-{service_id}-data-retention")
+    def update_service_data_retention(
+        self, service_id, data_retention_id, days_of_retention
+    ):
+        data = {"days_of_retention": days_of_retention}
+        return self.post(
+            "/service/{}/data-retention/{}".format(service_id, data_retention_id), data
+        )
 
-    @cache.set('service-{service_id}-data-retention')
+    @cache.set("service-{service_id}-data-retention")
     def get_service_data_retention(self, service_id):
         return self.get("/service/{}/data-retention".format(service_id))