Run auto-correct on app/ and tests/

app/__init__.py

@@ -1,22 +1,30 @@
-import time
 import os
 import random
 import string
+import time
 import uuid
+from time import monotonic
 
 from celery import current_task
-from flask import _request_ctx_stack, request, g, jsonify, make_response, current_app, has_request_context
-from flask_sqlalchemy import SQLAlchemy as _SQLAlchemy
+from flask import (
+    _request_ctx_stack,
+    current_app,
+    g,
+    has_request_context,
+    jsonify,
+    make_response,
+    request,
+)
 from flask_marshmallow import Marshmallow
 from flask_migrate import Migrate
+from flask_sqlalchemy import SQLAlchemy as _SQLAlchemy
 from gds_metrics import GDSMetrics
 from gds_metrics.metrics import Gauge, Histogram
-from time import monotonic
-from notifications_utils.clients.zendesk.zendesk_client import ZendeskClient
-from notifications_utils.clients.statsd.statsd_client import StatsdClient
-from notifications_utils.clients.redis.redis_client import RedisClient
-from notifications_utils.clients.encryption.encryption_client import Encryption
 from notifications_utils import logging, request_helper
+from notifications_utils.clients.encryption.encryption_client import Encryption
+from notifications_utils.clients.redis.redis_client import RedisClient
+from notifications_utils.clients.statsd.statsd_client import StatsdClient
+from notifications_utils.clients.zendesk.zendesk_client import ZendeskClient
 from sqlalchemy import event
 from werkzeug.exceptions import HTTPException as WerkzeugHTTPException
 from werkzeug.local import LocalProxy
@@ -27,9 +35,11 @@ from app.clients.cbc_proxy import CBCProxyClient
 from app.clients.document_download import DocumentDownloadClient
 from app.clients.email.aws_ses import AwsSesClient
 from app.clients.email.aws_ses_stub import AwsSesStubClient
+from app.clients.performance_platform.performance_platform_client import (
+    PerformancePlatformClient,
+)
 from app.clients.sms.firetext import FiretextClient
 from app.clients.sms.mmg import MMGClient
-from app.clients.performance_platform.performance_platform_client import PerformancePlatformClient
 
 
 class SQLAlchemy(_SQLAlchemy):
@@ -126,36 +136,52 @@ def create_app(application):
 
 
 def register_blueprint(application):
-    from app.service.rest import service_blueprint
-    from app.service.callback_rest import service_callback_blueprint
-    from app.user.rest import user_blueprint
-    from app.template.rest import template_blueprint
-    from app.status.healthcheck import status as status_blueprint
-    from app.job.rest import job_blueprint
-    from app.notifications.rest import notifications as notifications_blueprint
-    from app.invite.rest import invite as invite_blueprint
     from app.accept_invite.rest import accept_invite
-    from app.template_statistics.rest import template_statistics as template_statistics_blueprint
-    from app.events.rest import events as events_blueprint
-    from app.provider_details.rest import provider_details as provider_details_blueprint
+    from app.authentication.auth import (
+        requires_admin_auth,
+        requires_auth,
+        requires_no_auth,
+    )
+    from app.billing.rest import billing_blueprint
+    from app.broadcast_message.rest import broadcast_message_blueprint
+    from app.complaint.complaint_rest import complaint_blueprint
     from app.email_branding.rest import email_branding_blueprint
+    from app.events.rest import events as events_blueprint
     from app.inbound_number.rest import inbound_number_blueprint
     from app.inbound_sms.rest import inbound_sms as inbound_sms_blueprint
-    from app.notifications.receive_notifications import receive_notifications_blueprint
-    from app.notifications.notifications_sms_callback import sms_callback_blueprint
-    from app.notifications.notifications_letter_callback import letter_callback_blueprint
-    from app.authentication.auth import requires_admin_auth, requires_auth, requires_no_auth
+    from app.invite.rest import invite as invite_blueprint
+    from app.job.rest import job_blueprint
+    from app.letter_branding.letter_branding_rest import (
+        letter_branding_blueprint,
+    )
     from app.letters.rest import letter_job
-    from app.billing.rest import billing_blueprint
-    from app.organisation.rest import organisation_blueprint
+    from app.notifications.notifications_letter_callback import (
+        letter_callback_blueprint,
+    )
+    from app.notifications.notifications_sms_callback import (
+        sms_callback_blueprint,
+    )
+    from app.notifications.receive_notifications import (
+        receive_notifications_blueprint,
+    )
+    from app.notifications.rest import notifications as notifications_blueprint
     from app.organisation.invite_rest import organisation_invite_blueprint
-    from app.complaint.complaint_rest import complaint_blueprint
+    from app.organisation.rest import organisation_blueprint
     from app.performance_dashboard.rest import performance_dashboard_blueprint
     from app.platform_stats.rest import platform_stats_blueprint
+    from app.provider_details.rest import (
+        provider_details as provider_details_blueprint,
+    )
+    from app.service.callback_rest import service_callback_blueprint
+    from app.service.rest import service_blueprint
+    from app.status.healthcheck import status as status_blueprint
+    from app.template.rest import template_blueprint
     from app.template_folder.rest import template_folder_blueprint
-    from app.letter_branding.letter_branding_rest import letter_branding_blueprint
+    from app.template_statistics.rest import (
+        template_statistics as template_statistics_blueprint,
+    )
     from app.upload.rest import upload_blueprint
-    from app.broadcast_message.rest import broadcast_message_blueprint
+    from app.user.rest import user_blueprint
 
     service_blueprint.before_request(requires_admin_auth)
     application.register_blueprint(service_blueprint, url_prefix='/service')
@@ -249,14 +275,28 @@ def register_blueprint(application):
 
 
 def register_v2_blueprints(application):
-    from app.v2.inbound_sms.get_inbound_sms import v2_inbound_sms_blueprint as get_inbound_sms
-    from app.v2.notifications.post_notifications import v2_notification_blueprint as post_notifications
-    from app.v2.notifications.get_notifications import v2_notification_blueprint as get_notifications
-    from app.v2.template.get_template import v2_template_blueprint as get_template
-    from app.v2.templates.get_templates import v2_templates_blueprint as get_templates
-    from app.v2.template.post_template import v2_template_blueprint as post_template
-    from app.v2.broadcast.post_broadcast import v2_broadcast_blueprint as post_broadcast
     from app.authentication.auth import requires_auth
+    from app.v2.broadcast.post_broadcast import (
+        v2_broadcast_blueprint as post_broadcast,
+    )
+    from app.v2.inbound_sms.get_inbound_sms import (
+        v2_inbound_sms_blueprint as get_inbound_sms,
+    )
+    from app.v2.notifications.get_notifications import (
+        v2_notification_blueprint as get_notifications,
+    )
+    from app.v2.notifications.post_notifications import (
+        v2_notification_blueprint as post_notifications,
+    )
+    from app.v2.template.get_template import (
+        v2_template_blueprint as get_template,
+    )
+    from app.v2.template.post_template import (
+        v2_template_blueprint as post_template,
+    )
+    from app.v2.templates.get_templates import (
+        v2_templates_blueprint as get_templates,
+    )
 
     post_notifications.before_request(requires_auth)
     application.register_blueprint(post_notifications)

app/accept_invite/rest.py

@@ -1,24 +1,12 @@
-from flask import (
-    Blueprint,
-    jsonify,
-    current_app
-)
-
-from itsdangerous import SignatureExpired, BadData
-
+from flask import Blueprint, current_app, jsonify
+from itsdangerous import BadData, SignatureExpired
 from notifications_utils.url_safe_token import check_token
 
 from app.dao.invited_user_dao import get_invited_user_by_id
 from app.dao.organisation_dao import dao_get_invited_organisation_user
-
-from app.errors import (
-    register_errors,
-    InvalidRequest
-)
-
+from app.errors import InvalidRequest, register_errors
 from app.schemas import invited_user_schema
 
-
 accept_invite = Blueprint('accept_invite', __name__)
 register_errors(accept_invite)
 

app/authentication/auth.py

@@ -1,16 +1,22 @@
-from flask import request, _request_ctx_stack, current_app, g
-from notifications_python_client.authentication import decode_jwt_token, get_token_issuer
+from flask import _request_ctx_stack, current_app, g, request
+from gds_metrics import Histogram
+from notifications_python_client.authentication import (
+    decode_jwt_token,
+    get_token_issuer,
+)
 from notifications_python_client.errors import (
-    TokenDecodeError, TokenExpiredError, TokenIssuerError, TokenAlgorithmError, TokenError
+    TokenAlgorithmError,
+    TokenDecodeError,
+    TokenError,
+    TokenExpiredError,
+    TokenIssuerError,
 )
 from notifications_utils import request_helper
 from sqlalchemy.exc import DataError
 from sqlalchemy.orm.exc import NoResultFound
-from gds_metrics import Histogram
 
 from app.serialised_models import SerialisedService
 
-
 GENERAL_TOKEN_ERROR_MESSAGE = 'Invalid token: make sure your API token matches the example at https://docs.notifications.service.gov.uk/rest-api.html#authorisation-header'  # noqa
 
 AUTH_DB_CONNECTION_DURATION_SECONDS = Histogram(

app/aws/s3.py

@@ -1,7 +1,6 @@
-from flask import current_app
-
-from boto3 import client, resource
 import botocore
+from boto3 import client, resource
+from flask import current_app
 
 FILE_LOCATION_STRUCTURE = 'service-{}-notify/{}.csv'
 

app/billing/billing_schemas.py

@@ -1,6 +1,5 @@
 from datetime import datetime
 
-
 create_or_update_free_sms_fragment_limit_schema = {
     "$schema": "http://json-schema.org/draft-04/schema#",
     "description": "POST annual billing schema",

app/billing/rest.py

@@ -6,18 +6,17 @@ from app.billing.billing_schemas import (
     serialize_ft_billing_yearly_totals,
 )
 from app.dao.annual_billing_dao import (
-    dao_get_free_sms_fragment_limit_for_year,
-    dao_get_all_free_sms_fragment_limit,
     dao_create_or_update_annual_billing_for_year,
-    dao_update_annual_billing_for_future_years
+    dao_get_all_free_sms_fragment_limit,
+    dao_get_free_sms_fragment_limit_for_year,
+    dao_update_annual_billing_for_future_years,
 )
 from app.dao.date_util import get_current_financial_year_start_year
 from app.dao.fact_billing_dao import (
-    fetch_monthly_billing_for_year, fetch_billing_totals_for_year,
+    fetch_billing_totals_for_year,
+    fetch_monthly_billing_for_year,
 )
-
-from app.errors import InvalidRequest
-from app.errors import register_errors
+from app.errors import InvalidRequest, register_errors
 from app.schema_validation import validate
 
 billing_blueprint = Blueprint(

app/broadcast_message/broadcast_message_schema.py

@@ -1,5 +1,5 @@
-from app.schema_validation.definitions import uuid
 from app.models import BroadcastStatusType
+from app.schema_validation.definitions import uuid
 
 create_broadcast_message_schema = {
     '$schema': 'http://json-schema.org/draft-04/schema#',

app/broadcast_message/rest.py

@@ -1,25 +1,30 @@
 from datetime import datetime
 
 import iso8601
+from flask import Blueprint, current_app, jsonify, request
 
-from flask import Blueprint, jsonify, request, current_app
-from app.config import QueueNames
-from app.dao.dao_utils import dao_save_object
-from app.dao.templates_dao import dao_get_template_by_id_and_service_id
-from app.dao.users_dao import get_user_by_id
-from app.dao.broadcast_message_dao import (
-    dao_get_broadcast_message_by_id_and_service_id,
-    dao_get_broadcast_messages_for_service,
-)
-from app.dao.services_dao import dao_fetch_service_by_id
-from app.errors import register_errors, InvalidRequest
-from app.models import BroadcastMessage, BroadcastStatusType, BroadcastEvent, BroadcastEventMessageType
-from app.celery.broadcast_message_tasks import send_broadcast_event
 from app.broadcast_message.broadcast_message_schema import (
     create_broadcast_message_schema,
     update_broadcast_message_schema,
     update_broadcast_message_status_schema,
 )
+from app.celery.broadcast_message_tasks import send_broadcast_event
+from app.config import QueueNames
+from app.dao.broadcast_message_dao import (
+    dao_get_broadcast_message_by_id_and_service_id,
+    dao_get_broadcast_messages_for_service,
+)
+from app.dao.dao_utils import dao_save_object
+from app.dao.services_dao import dao_fetch_service_by_id
+from app.dao.templates_dao import dao_get_template_by_id_and_service_id
+from app.dao.users_dao import get_user_by_id
+from app.errors import InvalidRequest, register_errors
+from app.models import (
+    BroadcastEvent,
+    BroadcastEventMessageType,
+    BroadcastMessage,
+    BroadcastStatusType,
+)
 from app.schema_validation import validate
 
 broadcast_message_blueprint = Blueprint(

app/celery/broadcast_message_tasks.py

@@ -6,15 +6,21 @@ from notifications_utils.statsd_decorators import statsd
 from sqlalchemy.schema import Sequence
 
 from app import cbc_proxy_client, db, notify_celery
-from app.clients.cbc_proxy import CBCProxyFatalException, CBCProxyRetryableException
+from app.clients.cbc_proxy import (
+    CBCProxyFatalException,
+    CBCProxyRetryableException,
+)
 from app.config import QueueNames
-from app.models import BroadcastEventMessageType, BroadcastProvider, BroadcastProviderMessageStatus
 from app.dao.broadcast_message_dao import (
+    create_broadcast_provider_message,
     dao_get_broadcast_event_by_id,
-    create_broadcast_provider_message,
-    update_broadcast_provider_message_status
+    update_broadcast_provider_message_status,
+)
+from app.models import (
+    BroadcastEventMessageType,
+    BroadcastProvider,
+    BroadcastProviderMessageStatus,
 )
-
 from app.utils import format_sequential_number
 
 

app/celery/celery.py

@@ -1,9 +1,10 @@
 import time
-from gds_metrics.metrics import Histogram
+
 from celery import Celery, Task
 from celery.signals import worker_process_shutdown
 from flask import g, request
-from flask.ctx import has_request_context, has_app_context
+from flask.ctx import has_app_context, has_request_context
+from gds_metrics.metrics import Histogram
 
 
 @worker_process_shutdown.connect

app/celery/letters_pdf_tasks.py

@@ -1,18 +1,18 @@
+from base64 import urlsafe_b64encode
 from datetime import datetime, timedelta
 from hashlib import sha512
-from base64 import urlsafe_b64encode
 
 from botocore.exceptions import ClientError as BotoClientError
 from flask import current_app
-from notifications_utils.postal_address import PostalAddress
-
-from notifications_utils.statsd_decorators import statsd
 from notifications_utils.letter_timings import LETTER_PROCESSING_DEADLINE
+from notifications_utils.postal_address import PostalAddress
+from notifications_utils.statsd_decorators import statsd
 from notifications_utils.timezones import convert_utc_to_bst
 
 from app import encryption, notify_celery
 from app.aws import s3
 from app.config import QueueNames, TaskNames
+from app.cronitor import cronitor
 from app.dao.notifications_dao import (
     dao_get_letters_and_sheets_volume_by_postage,
     dao_get_letters_to_be_printed,
@@ -23,18 +23,18 @@ from app.dao.notifications_dao import (
     update_notification_status_by_id,
 )
 from app.dao.templates_dao import dao_get_template_by_id
-from app.letters.utils import get_letter_pdf_filename
 from app.errors import VirusScanError
 from app.exceptions import NotificationTechnicalFailureException
 from app.letters.utils import (
-    get_billable_units_for_letter_page_count,
-    get_reference_from_filename,
     ScanErrorType,
+    get_billable_units_for_letter_page_count,
+    get_file_names_from_error_bucket,
+    get_letter_pdf_filename,
+    get_reference_from_filename,
+    move_error_pdf_to_scan_bucket,
     move_failed_pdf,
     move_sanitised_letter_to_test_or_live_pdf_bucket,
     move_scan_to_invalid_pdf_bucket,
-    move_error_pdf_to_scan_bucket,
-    get_file_names_from_error_bucket,
 )
 from app.models import (
     INTERNATIONAL_LETTERS,
@@ -52,8 +52,6 @@ from app.models import (
     Service,
 )
 
-from app.cronitor import cronitor
-
 
 @notify_celery.task(bind=True, name="get-pdf-for-templated-letter", max_retries=15, default_retry_delay=300)
 @statsd(namespace="tasks")
@@ -214,7 +212,7 @@ def send_letters_volume_email_to_dvla(letters_volumes, date):
     # avoid circular imports:
     from app.notifications.process_notifications import (
         persist_notification,
-        send_notification_to_queue
+        send_notification_to_queue,
     )
     for recipient in recipients:
         saved_notification = persist_notification(

app/celery/nightly_tasks.py

@@ -1,7 +1,4 @@
-from datetime import (
-    datetime,
-    timedelta
-)
+from datetime import datetime, timedelta
 
 import pytz
 from flask import current_app
@@ -12,31 +9,33 @@ from sqlalchemy.exc import SQLAlchemyError
 from app import notify_celery, performance_platform_client, zendesk_client
 from app.aws import s3
 from app.celery.service_callback_tasks import (
-    send_delivery_status_to_service,
     create_delivery_status_callback_data,
+    send_delivery_status_to_service,
 )
 from app.config import QueueNames
+from app.cronitor import cronitor
 from app.dao.inbound_sms_dao import delete_inbound_sms_older_than_retention
 from app.dao.jobs_dao import (
+    dao_archive_job,
     dao_get_jobs_older_than_data_retention,
-    dao_archive_job
 )
 from app.dao.notifications_dao import (
     dao_timeout_notifications,
     delete_notifications_older_than_retention_by_type,
 )
-from app.dao.service_callback_api_dao import get_service_delivery_status_callback_api_for_service
+from app.dao.service_callback_api_dao import (
+    get_service_delivery_status_callback_api_for_service,
+)
 from app.exceptions import NotificationTechnicalFailureException
 from app.models import (
-    Notification,
-    NOTIFICATION_SENDING,
     EMAIL_TYPE,
-    SMS_TYPE,
+    KEY_TYPE_NORMAL,
     LETTER_TYPE,
-    KEY_TYPE_NORMAL
+    NOTIFICATION_SENDING,
+    SMS_TYPE,
+    Notification,
 )
-from app.performance_platform import total_sent_notifications, processing_time
-from app.cronitor import cronitor
+from app.performance_platform import processing_time, total_sent_notifications
 from app.utils import get_london_midnight_in_utc
 
 

app/celery/process_ses_receipts_tasks.py

@@ -7,16 +7,15 @@ from notifications_utils.statsd_decorators import statsd
 from sqlalchemy.orm.exc import NoResultFound
 
 from app import notify_celery, statsd_client
-from app.config import QueueNames
 from app.clients.email.aws_ses import get_aws_responses
+from app.config import QueueNames
 from app.dao import notifications_dao
-from app.models import NOTIFICATION_SENDING, NOTIFICATION_PENDING
-
+from app.models import NOTIFICATION_PENDING, NOTIFICATION_SENDING
 from app.notifications.notifications_ses_callback import (
+    _check_and_queue_callback_task,
+    _check_and_queue_complaint_callback_task,
     determine_notification_bounce_type,
     handle_complaint,
-    _check_and_queue_complaint_callback_task,
-    _check_and_queue_callback_task,
 )
 
 

app/celery/process_sms_client_response_tasks.py

@@ -6,13 +6,18 @@ from notifications_utils.statsd_decorators import statsd
 from notifications_utils.template import SMSMessageTemplate
 
 from app import notify_celery, statsd_client
+from app.celery.service_callback_tasks import (
+    create_delivery_status_callback_data,
+    send_delivery_status_to_service,
+)
 from app.clients import ClientException
 from app.clients.sms.firetext import get_firetext_responses
 from app.clients.sms.mmg import get_mmg_responses
-from app.celery.service_callback_tasks import send_delivery_status_to_service, create_delivery_status_callback_data
 from app.config import QueueNames
 from app.dao import notifications_dao
-from app.dao.service_callback_api_dao import get_service_delivery_status_callback_api_for_service
+from app.dao.service_callback_api_dao import (
+    get_service_delivery_status_callback_api_for_service,
+)
 from app.dao.templates_dao import dao_get_template_by_id
 from app.models import NOTIFICATION_PENDING
 

app/celery/provider_tasks.py

@@ -3,10 +3,10 @@ from notifications_utils.statsd_decorators import statsd
 from sqlalchemy.orm.exc import NoResultFound
 
 from app import notify_celery
-from app.config import QueueNames
 from app.clients.email import EmailClientNonRetryableException
 from app.clients.email.aws_ses import AwsSesClientThrottlingSendRateException
 from app.clients.sms import SmsClientResponseException
+from app.config import QueueNames
 from app.dao import notifications_dao
 from app.dao.notifications_dao import update_notification_status_by_id
 from app.delivery import send_to_providers

app/celery/reporting_tasks.py

@@ -9,14 +9,13 @@ from app.config import QueueNames
 from app.cronitor import cronitor
 from app.dao.fact_billing_dao import (
     fetch_billing_data_for_day,
-    update_fact_billing
+    update_fact_billing,
 )
-from app.dao.fact_notification_status_dao import fetch_notification_status_for_day, update_fact_notification_status
-from app.models import (
-    SMS_TYPE,
-    EMAIL_TYPE,
-    LETTER_TYPE,
+from app.dao.fact_notification_status_dao import (
+    fetch_notification_status_for_day,
+    update_fact_notification_status,
 )
+from app.models import EMAIL_TYPE, LETTER_TYPE, SMS_TYPE
 
 
 @notify_celery.task(name="create-nightly-billing")

app/celery/research_mode_tasks.py

@@ -1,17 +1,16 @@
+import json
 import random
 from datetime import datetime, timedelta
-import json
 
 from flask import current_app
-from requests import request, HTTPError
-
 from notifications_utils.s3 import s3upload
+from requests import HTTPError, request
 
 from app import notify_celery
 from app.aws.s3 import file_exists
-from app.models import SMS_TYPE
-from app.config import QueueNames
 from app.celery.process_ses_receipts_tasks import process_ses_results
+from app.config import QueueNames
+from app.models import SMS_TYPE
 
 temp_fail = "7700900003"
 perm_fail = "7700900002"

app/celery/scheduled_tasks.py

@@ -1,9 +1,5 @@
 import uuid
-
-from datetime import (
-    datetime,
-    timedelta
-)
+from datetime import datetime, timedelta
 
 from flask import current_app
 from notifications_utils.statsd_decorators import statsd
@@ -11,41 +7,49 @@ from sqlalchemy import and_
 from sqlalchemy.exc import SQLAlchemyError
 
 from app import cbc_proxy_client, notify_celery, zendesk_client
-from app.celery.tasks import (
-    process_job,
-    get_recipient_csv_and_template_and_sender_id,
-    process_row,
-    process_incomplete_jobs)
-from app.celery.letters_pdf_tasks import get_pdf_for_templated_letter
 from app.celery.broadcast_message_tasks import trigger_link_test
+from app.celery.letters_pdf_tasks import get_pdf_for_templated_letter
+from app.celery.tasks import (
+    get_recipient_csv_and_template_and_sender_id,
+    process_incomplete_jobs,
+    process_job,
+    process_row,
+)
 from app.config import QueueNames
-from app.dao.invited_org_user_dao import delete_org_invitations_created_more_than_two_days_ago
-from app.dao.invited_user_dao import delete_invitations_created_more_than_two_days_ago
+from app.dao.invited_org_user_dao import (
+    delete_org_invitations_created_more_than_two_days_ago,
+)
+from app.dao.invited_user_dao import (
+    delete_invitations_created_more_than_two_days_ago,
+)
 from app.dao.jobs_dao import (
     dao_set_scheduled_jobs_to_pending,
+    dao_update_job,
     find_jobs_with_missing_rows,
-    find_missing_row_for_job
+    find_missing_row_for_job,
 )
-from app.dao.jobs_dao import dao_update_job
 from app.dao.notifications_dao import (
-    notifications_not_yet_sent,
-    dao_precompiled_letters_still_pending_virus_check,
     dao_old_letters_with_created_status,
-    letters_missing_from_sending_bucket,
+    dao_precompiled_letters_still_pending_virus_check,
     is_delivery_slow_for_providers,
+    letters_missing_from_sending_bucket,
+    notifications_not_yet_sent,
 )
 from app.dao.provider_details_dao import (
+    dao_adjust_provider_priority_back_to_resting_points,
     dao_reduce_sms_provider_priority,
-    dao_adjust_provider_priority_back_to_resting_points
+)
+from app.dao.services_dao import (
+    dao_find_services_sending_to_tv_numbers,
+    dao_find_services_with_high_failure_rates,
 )
 from app.dao.users_dao import delete_codes_older_created_more_than_a_day_ago
-from app.dao.services_dao import dao_find_services_sending_to_tv_numbers, dao_find_services_with_high_failure_rates
 from app.models import (
-    Job,
-    JOB_STATUS_IN_PROGRESS,
-    JOB_STATUS_ERROR,
-    SMS_TYPE,
     EMAIL_TYPE,
+    JOB_STATUS_ERROR,
+    JOB_STATUS_IN_PROGRESS,
+    SMS_TYPE,
+    Job,
 )
 from app.notifications.process_notifications import send_notification_to_queue
 

app/celery/service_callback_tasks.py

@@ -2,11 +2,7 @@ import json
 
 from flask import current_app
 from notifications_utils.statsd_decorators import statsd
-from requests import (
-    HTTPError,
-    request,
-    RequestException
-)
+from requests import HTTPError, RequestException, request
 
 from app import encryption, notify_celery
 from app.config import QueueNames

app/celery/tasks.py

@@ -1,6 +1,6 @@
 import json
+from collections import defaultdict, namedtuple
 from datetime import datetime
-from collections import namedtuple, defaultdict
 
 from flask import current_app
 from notifications_utils.columns import Columns
@@ -8,36 +8,28 @@ from notifications_utils.postal_address import PostalAddress
 from notifications_utils.recipients import RecipientCSV
 from notifications_utils.statsd_decorators import statsd
 from notifications_utils.timezones import convert_utc_to_bst
-from requests import (
-    HTTPError,
-    request,
-    RequestException
-)
-from sqlalchemy.exc import SQLAlchemyError, IntegrityError
+from requests import HTTPError, RequestException, request
+from sqlalchemy.exc import IntegrityError, SQLAlchemyError
 
-from app import (
-    create_uuid,
-    create_random_identifier,
-    encryption,
-    notify_celery,
-)
+from app import create_random_identifier, create_uuid, encryption, notify_celery
 from app.aws import s3
-from app.celery import provider_tasks, letters_pdf_tasks, research_mode_tasks
+from app.celery import letters_pdf_tasks, provider_tasks, research_mode_tasks
 from app.config import QueueNames
-from app.dao.daily_sorted_letter_dao import dao_create_or_update_daily_sorted_letter
+from app.dao.daily_sorted_letter_dao import (
+    dao_create_or_update_daily_sorted_letter,
+)
 from app.dao.inbound_sms_dao import dao_get_inbound_sms_by_id
-from app.dao.jobs_dao import (
-    dao_update_job,
-    dao_get_job_by_id,
-)
+from app.dao.jobs_dao import dao_get_job_by_id, dao_update_job
 from app.dao.notifications_dao import (
-    get_notification_by_id,
-    dao_update_notifications_by_reference,
     dao_get_last_notification_added_for_job_id,
-    update_notification_status_by_reference,
     dao_get_notification_or_history_by_reference,
+    dao_update_notifications_by_reference,
+    get_notification_by_id,
+    update_notification_status_by_reference,
+)
+from app.dao.provider_details_dao import (
+    get_provider_details_by_notification_type,
 )
-from app.dao.provider_details_dao import get_provider_details_by_notification_type
 from app.dao.returned_letters_dao import insert_or_update_returned_letters
 from app.dao.service_email_reply_to_dao import dao_get_reply_to_by_id
 from app.dao.service_inbound_api_dao import get_service_inbound_api_for_service
@@ -56,16 +48,16 @@ from app.models import (
     LETTER_TYPE,
     NOTIFICATION_CREATED,
     NOTIFICATION_DELIVERED,
-    NOTIFICATION_SENDING,
-    NOTIFICATION_TEMPORARY_FAILURE,
-    NOTIFICATION_TECHNICAL_FAILURE,
     NOTIFICATION_RETURNED_LETTER,
+    NOTIFICATION_SENDING,
+    NOTIFICATION_TECHNICAL_FAILURE,
+    NOTIFICATION_TEMPORARY_FAILURE,
     SMS_TYPE,
     DailySortedLetter,
 )
 from app.notifications.process_notifications import persist_notification
-from app.service.utils import service_allowed_to_send_to
 from app.serialised_models import SerialisedService, SerialisedTemplate
+from app.service.utils import service_allowed_to_send_to
 from app.utils import DATETIME_FORMAT
 
 

app/clients/document_download.py

@@ -1,5 +1,4 @@
 import requests
-
 from flask import current_app
 
 

app/clients/email/__init__.py

@@ -1,4 +1,4 @@
-from app.clients import ClientException, Client
+from app.clients import Client, ClientException
 
 
 class EmailClientException(ClientException):

app/clients/email/aws_ses.py

@@ -1,10 +1,15 @@
+from time import monotonic
+
 import boto3
 import botocore
 from flask import current_app
-from time import monotonic
 
 from app.clients import STATISTICS_DELIVERED, STATISTICS_FAILURE
-from app.clients.email import EmailClient, EmailClientException, EmailClientNonRetryableException
+from app.clients.email import (
+    EmailClient,
+    EmailClientException,
+    EmailClientNonRetryableException,
+)
 
 ses_response_map = {
     'Permanent': {

app/clients/email/aws_ses_stub.py

@@ -1,10 +1,10 @@
 import json
+from time import monotonic
 
 from flask import current_app
 from requests import request
-from time import monotonic
 
-from app.clients.email import (EmailClientException, EmailClient)
+from app.clients.email import EmailClient, EmailClientException
 
 
 class AwsSesStubClientException(EmailClientException):

app/clients/performance_platform/performance_platform_client.py

@@ -1,9 +1,8 @@
 import base64
 import json
 
-from flask import current_app
 import requests
-
+from flask import current_app
 from notifications_utils.timezones import convert_utc_to_bst
 
 

app/clients/sms/__init__.py

@@ -1,4 +1,4 @@
-from app.clients import (Client, ClientException)
+from app.clients import Client, ClientException
 
 
 class SmsClientResponseException(ClientException):

app/clients/sms/firetext.py

@@ -1,10 +1,10 @@
 import json
 import logging
-
 from time import monotonic
-from requests import request, RequestException
 
-from app.clients.sms import (SmsClient, SmsClientResponseException)
+from requests import RequestException, request
+
+from app.clients.sms import SmsClient, SmsClientResponseException
 
 logger = logging.getLogger(__name__)
 

app/clients/sms/mmg.py

@@ -1,7 +1,9 @@
 import json
 from time import monotonic
-from requests import (request, RequestException)
-from app.clients.sms import (SmsClient, SmsClientResponseException)
+
+from requests import RequestException, request
+
+from app.clients.sms import SmsClient, SmsClientResponseException
 
 mmg_response_map = {
     '2': {'status': 'permanent-failure', 'substatus': {

app/cloudfoundry_config.py

@@ -3,8 +3,8 @@ Extracts cloudfoundry config from its json and populates the environment variabl
 on local/aws boxes
 """
 
-import os
 import json
+import os
 
 
 def extract_cloudfoundry_config():

app/commands.py

@@ -1,29 +1,35 @@
 import csv
 import functools
+import itertools
 import uuid
 from datetime import datetime, timedelta
 from decimal import Decimal
 
 import click
 import flask
-import itertools
 from click_datetime import Datetime as click_dt
 from flask import current_app, json
 from notifications_utils.recipients import RecipientCSV
+from notifications_utils.statsd_decorators import statsd
 from notifications_utils.template import SMSMessageTemplate
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm.exc import NoResultFound
-from notifications_utils.statsd_decorators import statsd
 
 from app import db, encryption
 from app.aws import s3
-from app.celery.tasks import record_daily_sorted_counts, process_row
-from app.celery.nightly_tasks import send_total_sent_notifications_to_performance_platform
-from app.celery.service_callback_tasks import send_delivery_status_to_service
 from app.celery.letters_pdf_tasks import get_pdf_for_templated_letter
-from app.celery.reporting_tasks import create_nightly_notification_status_for_day
+from app.celery.nightly_tasks import (
+    send_total_sent_notifications_to_performance_platform,
+)
+from app.celery.reporting_tasks import (
+    create_nightly_notification_status_for_day,
+)
+from app.celery.service_callback_tasks import send_delivery_status_to_service
+from app.celery.tasks import process_row, record_daily_sorted_counts
 from app.config import QueueNames
-from app.dao.annual_billing_dao import dao_create_or_update_annual_billing_for_year
+from app.dao.annual_billing_dao import (
+    dao_create_or_update_annual_billing_for_year,
+)
 from app.dao.fact_billing_dao import (
     delete_billing_data_for_service_for_day,
     fetch_billing_data_for_day,
@@ -32,36 +38,53 @@ from app.dao.fact_billing_dao import (
 )
 from app.dao.fact_processing_time_dao import insert_update_processing_time
 from app.dao.jobs_dao import dao_get_job_by_id
-from app.dao.organisation_dao import dao_get_organisation_by_email_address, dao_add_service_to_organisation
-
-from app.dao.provider_rates_dao import create_provider_rates as dao_create_provider_rates
-from app.dao.service_callback_api_dao import get_service_delivery_status_callback_api_for_service
+from app.dao.organisation_dao import (
+    dao_add_service_to_organisation,
+    dao_get_organisation_by_email_address,
+)
+from app.dao.provider_rates_dao import (
+    create_provider_rates as dao_create_provider_rates,
+)
+from app.dao.service_callback_api_dao import (
+    get_service_delivery_status_callback_api_for_service,
+)
 from app.dao.services_dao import (
-    delete_service_and_all_associated_db_objects,
     dao_fetch_all_services_by_user,
     dao_fetch_all_services_created_by_user,
     dao_fetch_service_by_id,
-    dao_update_service
+    dao_update_service,
+    delete_service_and_all_associated_db_objects,
 )
 from app.dao.templates_dao import dao_get_template_by_id
-from app.dao.users_dao import delete_model_user, delete_user_verify_codes, get_user_by_email
+from app.dao.users_dao import (
+    delete_model_user,
+    delete_user_verify_codes,
+    get_user_by_email,
+)
 from app.models import (
-    PROVIDERS,
-    NOTIFICATION_CREATED,
-    KEY_TYPE_TEST,
-    SMS_TYPE,
     EMAIL_TYPE,
+    KEY_TYPE_TEST,
     LETTER_TYPE,
-    User,
+    NOTIFICATION_CREATED,
+    PROVIDERS,
+    SMS_TYPE,
+    Domain,
+    EmailBranding,
+    FactProcessingTime,
+    LetterBranding,
     Notification,
     Organisation,
-    Domain,
     Service,
-    EmailBranding,
-    LetterBranding, FactProcessingTime,
+    User,
+)
+from app.performance_platform.processing_time import (
+    send_processing_time_for_start_and_end,
+)
+from app.utils import (
+    DATETIME_FORMAT,
+    get_london_midnight_in_utc,
+    get_midnight_for_day_before,
 )
-from app.performance_platform.processing_time import send_processing_time_for_start_and_end
-from app.utils import DATETIME_FORMAT, get_london_midnight_in_utc, get_midnight_for_day_before
 
 
 @click.group(name='command', help='Additional commands')

app/complaint/complaint_rest.py

@@ -3,7 +3,10 @@ from datetime import datetime
 from flask import Blueprint, jsonify, request
 
 from app.complaint.complaint_schema import complaint_count_request
-from app.dao.complaint_dao import fetch_count_of_complaints, fetch_paginated_complaints
+from app.dao.complaint_dao import (
+    fetch_count_of_complaints,
+    fetch_paginated_complaints,
+)
 from app.errors import register_errors
 from app.schema_validation import validate
 from app.utils import pagination_links

app/config.py

@@ -1,6 +1,6 @@
-from datetime import timedelta
-import os
 import json
+import os
+from datetime import timedelta
 
 from celery.schedules import crontab
 from kombu import Exchange, Queue

app/cronitor.py

@@ -1,5 +1,6 @@
-import requests
 from functools import wraps
+
+import requests
 from flask import current_app
 
 

app/dao/__init__.py

@@ -1,4 +1,5 @@
 from sqlalchemy.exc import SQLAlchemyError
+
 from app import db
 
 

app/dao/annual_billing_dao.py

@@ -1,7 +1,7 @@
 from app import db
 from app.dao.dao_utils import transactional
-from app.models import AnnualBilling
 from app.dao.date_util import get_current_financial_year_start_year
+from app.models import AnnualBilling
 
 
 @transactional

app/dao/api_key_dao.py

@@ -1,16 +1,12 @@
 import uuid
 from datetime import datetime, timedelta
 
+from sqlalchemy import func, or_
+
 from app import db
+from app.dao.dao_utils import transactional, version_class
 from app.models import ApiKey
 
-from app.dao.dao_utils import (
-    transactional,
-    version_class
-)
-
-from sqlalchemy import or_, func
-
 
 @transactional
 @version_class(ApiKey)

app/dao/broadcast_message_dao.py

@@ -3,12 +3,12 @@ import uuid
 from app import db
 from app.dao.dao_utils import transactional
 from app.models import (
-    BroadcastMessage,
     BroadcastEvent,
+    BroadcastMessage,
     BroadcastProvider,
     BroadcastProviderMessage,
     BroadcastProviderMessageNumber,
-    BroadcastProviderMessageStatus
+    BroadcastProviderMessageStatus,
 )
 
 

app/dao/broadcast_service_dao.py

@@ -5,12 +5,12 @@ from flask import current_app
 from app import db
 from app.dao.dao_utils import transactional, version_class
 from app.models import (
+    BROADCAST_TYPE,
+    EMAIL_AUTH_TYPE,
+    Organisation,
     Service,
     ServiceBroadcastSettings,
     ServicePermission,
-    Organisation,
-    BROADCAST_TYPE,
-    EMAIL_AUTH_TYPE
 )
 
 

app/dao/date_util.py

@@ -1,7 +1,7 @@
-from datetime import datetime, timedelta, date, time
+from datetime import date, datetime, time, timedelta
 
-from notifications_utils.timezones import convert_bst_to_utc
 import pytz
+from notifications_utils.timezones import convert_bst_to_utc
 
 
 def get_months_for_financial_year(year):

app/dao/fact_billing_dao.py

@@ -1,34 +1,33 @@
-from datetime import datetime, timedelta, time, date
+from datetime import date, datetime, time, timedelta
 
 from flask import current_app
 from notifications_utils.timezones import convert_bst_to_utc, convert_utc_to_bst
+from sqlalchemy import Date, Integer, and_, desc, func
 from sqlalchemy.dialects.postgresql import insert
-from sqlalchemy import func, desc, Date, Integer, and_
 from sqlalchemy.sql.expression import case, literal
 
 from app import db
 from app.dao.date_util import (
     get_financial_year,
-    get_financial_year_for_datetime
+    get_financial_year_for_datetime,
 )
 from app.dao.organisation_dao import dao_get_organisation_live_services
-
 from app.models import (
-    FactBilling,
-    Service,
+    EMAIL_TYPE,
+    INTERNATIONAL_POSTAGE_TYPES,
     KEY_TYPE_TEST,
     LETTER_TYPE,
-    SMS_TYPE,
-    Rate,
-    LetterRate,
-    NotificationHistory,
-    EMAIL_TYPE,
+    NOTIFICATION_STATUS_TYPES_BILLABLE_FOR_LETTERS,
     NOTIFICATION_STATUS_TYPES_BILLABLE_SMS,
     NOTIFICATION_STATUS_TYPES_SENT_EMAILS,
-    NOTIFICATION_STATUS_TYPES_BILLABLE_FOR_LETTERS,
+    SMS_TYPE,
     AnnualBilling,
+    FactBilling,
+    LetterRate,
+    NotificationHistory,
     Organisation,
-    INTERNATIONAL_POSTAGE_TYPES,
+    Rate,
+    Service,
 )
 from app.utils import get_london_midnight_in_utc, get_notification_table_to_use
 

app/dao/fact_notification_status_dao.py

@@ -1,36 +1,36 @@
-from datetime import datetime, timedelta, time
+from datetime import datetime, time, timedelta
 
 from flask import current_app
 from notifications_utils.timezones import convert_bst_to_utc
-from sqlalchemy import case, func, Date
+from sqlalchemy import Date, case, func
 from sqlalchemy.dialects.postgresql import insert
-from sqlalchemy.sql.expression import literal, extract
+from sqlalchemy.sql.expression import extract, literal
 from sqlalchemy.types import DateTime, Integer
 
 from app import db
+from app.dao.dao_utils import transactional
 from app.models import (
-    FactNotificationStatus,
     KEY_TYPE_TEST,
-    Notification,
     NOTIFICATION_CANCELLED,
     NOTIFICATION_CREATED,
     NOTIFICATION_DELIVERED,
     NOTIFICATION_FAILED,
     NOTIFICATION_PENDING,
+    NOTIFICATION_PERMANENT_FAILURE,
     NOTIFICATION_SENDING,
     NOTIFICATION_SENT,
     NOTIFICATION_TECHNICAL_FAILURE,
     NOTIFICATION_TEMPORARY_FAILURE,
-    NOTIFICATION_PERMANENT_FAILURE,
+    FactNotificationStatus,
+    Notification,
     Service,
     Template,
 )
-from app.dao.dao_utils import transactional
 from app.utils import (
     get_london_midnight_in_utc,
-    midnight_n_days_ago,
     get_london_month_from_utc_column,
     get_notification_table_to_use,
+    midnight_n_days_ago,
 )
 
 

app/dao/inbound_sms_dao.py

@@ -1,11 +1,17 @@
 from flask import current_app
-from sqlalchemy import desc, and_
-from sqlalchemy.orm import aliased
+from sqlalchemy import and_, desc
 from sqlalchemy.dialects.postgresql import insert
+from sqlalchemy.orm import aliased
 
 from app import db
 from app.dao.dao_utils import transactional
-from app.models import InboundSms, InboundSmsHistory, Service, ServiceDataRetention, SMS_TYPE
+from app.models import (
+    SMS_TYPE,
+    InboundSms,
+    InboundSmsHistory,
+    Service,
+    ServiceDataRetention,
+)
 from app.utils import midnight_n_days_ago
 
 

app/dao/invited_org_user_dao.py

@@ -1,6 +1,6 @@
 from datetime import datetime, timedelta
-from app import db
 
+from app import db
 from app.models import InvitedOrganisationUser
 
 

app/dao/invited_user_dao.py

@@ -1,6 +1,6 @@
 from datetime import datetime, timedelta
-from app import db
 
+from app import db
 from app.models import InvitedUser
 
 

app/dao/jobs_dao.py

@@ -2,33 +2,30 @@ import uuid
 from datetime import datetime, timedelta
 
 from flask import current_app
-from notifications_utils.letter_timings import letter_can_be_cancelled, CANCELLABLE_JOB_LETTER_STATUSES
-from sqlalchemy import (
-    asc,
-    desc,
-    func,
-    and_
+from notifications_utils.letter_timings import (
+    CANCELLABLE_JOB_LETTER_STATUSES,
+    letter_can_be_cancelled,
 )
+from sqlalchemy import and_, asc, desc, func
 
 from app import db
 from app.dao.dao_utils import transactional
 from app.dao.templates_dao import dao_get_template_by_id
-from app.utils import midnight_n_days_ago
-
 from app.models import (
-    Job,
+    JOB_STATUS_CANCELLED,
     JOB_STATUS_FINISHED,
     JOB_STATUS_PENDING,
     JOB_STATUS_SCHEDULED,
     LETTER_TYPE,
-    Notification,
-    Template,
-    ServiceDataRetention,
-    NOTIFICATION_CREATED,
     NOTIFICATION_CANCELLED,
-    JOB_STATUS_CANCELLED,
-    FactNotificationStatus
+    NOTIFICATION_CREATED,
+    FactNotificationStatus,
+    Job,
+    Notification,
+    ServiceDataRetention,
+    Template,
 )
+from app.utils import midnight_n_days_ago
 
 
 def dao_get_notification_outcomes_for_job(service_id, job_id):

app/dao/notifications_dao.py

@@ -1,57 +1,61 @@
 import functools
+from datetime import datetime, timedelta
 from itertools import groupby
 from operator import attrgetter
-from datetime import (
-    datetime,
-    timedelta,
-)
 
 from botocore.exceptions import ClientError
 from flask import current_app
-from notifications_utils.international_billing_rates import INTERNATIONAL_BILLING_RATES
+from notifications_utils.international_billing_rates import (
+    INTERNATIONAL_BILLING_RATES,
+)
 from notifications_utils.recipients import (
-    validate_and_format_email_address,
     InvalidEmailError,
-    try_validate_and_format_phone_number
+    try_validate_and_format_phone_number,
+    validate_and_format_email_address,
 )
 from notifications_utils.timezones import convert_bst_to_utc, convert_utc_to_bst
-from sqlalchemy import (desc, func, asc, and_, or_)
+from sqlalchemy import and_, asc, desc, func, or_
 from sqlalchemy.orm import joinedload
 from sqlalchemy.orm.exc import NoResultFound
 from sqlalchemy.sql import functions
 from sqlalchemy.sql.expression import case
 from werkzeug.datastructures import MultiDict
 
-from app import db, create_uuid
-from app.aws.s3 import remove_s3_object, get_s3_bucket_objects
+from app import create_uuid, db
+from app.aws.s3 import get_s3_bucket_objects, remove_s3_object
+from app.clients.sms.firetext import (
+    get_message_status_and_reason_from_firetext_code,
+)
 from app.dao.dao_utils import transactional
 from app.letters.utils import get_letter_pdf_filename
 from app.models import (
-    FactNotificationStatus,
-    Notification,
-    NotificationHistory,
-    ProviderDetails,
+    EMAIL_TYPE,
     KEY_TYPE_NORMAL,
     KEY_TYPE_TEST,
     LETTER_TYPE,
     NOTIFICATION_CREATED,
     NOTIFICATION_DELIVERED,
-    NOTIFICATION_SENDING,
     NOTIFICATION_PENDING,
     NOTIFICATION_PENDING_VIRUS_CHECK,
-    NOTIFICATION_TECHNICAL_FAILURE,
-    NOTIFICATION_TEMPORARY_FAILURE,
     NOTIFICATION_PERMANENT_FAILURE,
+    NOTIFICATION_SENDING,
     NOTIFICATION_SENT,
     NOTIFICATION_STATUS_TYPES_COMPLETED,
+    NOTIFICATION_TECHNICAL_FAILURE,
+    NOTIFICATION_TEMPORARY_FAILURE,
     SMS_TYPE,
-    EMAIL_TYPE,
-    ServiceDataRetention,
+    FactNotificationStatus,
+    Notification,
+    NotificationHistory,
+    ProviderDetails,
     Service,
+    ServiceDataRetention,
+)
+from app.utils import (
+    escape_special_characters,
+    get_london_midnight_in_utc,
+    midnight_n_days_ago,
 )
-from app.utils import get_london_midnight_in_utc
-from app.utils import midnight_n_days_ago, escape_special_characters
-from app.clients.sms.firetext import get_message_status_and_reason_from_firetext_code
 
 
 def dao_get_last_date_template_was_used(template_id, service_id):

app/dao/organisation_dao.py

@@ -3,11 +3,11 @@ from sqlalchemy.sql.expression import func
 from app import db
 from app.dao.dao_utils import VersionOptions, transactional, version_class
 from app.models import (
-    Organisation,
     Domain,
     InvitedOrganisationUser,
+    Organisation,
     Service,
-    User
+    User,
 )
 
 

app/dao/permissions_dao.py

@@ -1,16 +1,16 @@
 from app import db
 from app.dao import DAOClass
 from app.models import (
-    Permission,
-    MANAGE_USERS,
-    MANAGE_TEMPLATES,
+    MANAGE_API_KEYS,
     MANAGE_SETTINGS,
-    SEND_TEXTS,
+    MANAGE_TEMPLATES,
+    MANAGE_USERS,
     SEND_EMAILS,
     SEND_LETTERS,
-    MANAGE_API_KEYS,
-    VIEW_ACTIVITY)
-
+    SEND_TEXTS,
+    VIEW_ACTIVITY,
+    Permission,
+)
 
 # Default permissions for a service
 default_service_permissions = [

app/dao/provider_details_dao.py

@@ -1,12 +1,18 @@
 from datetime import datetime, timedelta
 
+from flask import current_app
 from notifications_utils.timezones import convert_utc_to_bst
 from sqlalchemy import asc, desc, func
-from flask import current_app
 
-from app.dao.dao_utils import transactional
-from app.models import FactBilling, ProviderDetails, ProviderDetailsHistory, SMS_TYPE, User
 from app import db
+from app.dao.dao_utils import transactional
+from app.models import (
+    SMS_TYPE,
+    FactBilling,
+    ProviderDetails,
+    ProviderDetailsHistory,
+    User,
+)
 
 
 def get_provider_details_by_id(provider_details_id):

app/dao/provider_rates_dao.py

@@ -1,6 +1,6 @@
-from app.models import ProviderRates, ProviderDetails
 from app import db
 from app.dao.dao_utils import transactional
+from app.models import ProviderDetails, ProviderRates
 
 
 @transactional

app/dao/returned_letters_dao.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 
-from sqlalchemy import func, desc
+from sqlalchemy import desc, func
 from sqlalchemy.dialects.postgresql import insert
 
 from app import db

app/dao/service_callback_api_dao.py

@@ -1,10 +1,12 @@
 from datetime import datetime
 
-from app import db, create_uuid
+from app import create_uuid, db
 from app.dao.dao_utils import transactional, version_class
-from app.models import ServiceCallbackApi
-
-from app.models import DELIVERY_STATUS_CALLBACK_TYPE, COMPLAINT_CALLBACK_TYPE
+from app.models import (
+    COMPLAINT_CALLBACK_TYPE,
+    DELIVERY_STATUS_CALLBACK_TYPE,
+    ServiceCallbackApi,
+)
 
 
 @transactional

app/dao/service_inbound_api_dao.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 
-from app import db, create_uuid
+from app import create_uuid, db
 from app.dao.dao_utils import transactional, version_class
 from app.models import ServiceInboundApi
 

app/dao/services_dao.py

@@ -1,18 +1,14 @@
 import uuid
 from datetime import date, datetime, timedelta
 
-from sqlalchemy.sql.expression import asc, case, and_, func
-from sqlalchemy.orm import joinedload
-from sqlalchemy import cast, Float
 from flask import current_app
+from sqlalchemy import Float, cast
+from sqlalchemy.orm import joinedload
+from sqlalchemy.sql.expression import and_, asc, case, func
 
 from app import db
+from app.dao.dao_utils import VersionOptions, transactional, version_class
 from app.dao.date_util import get_current_financial_year
-from app.dao.dao_utils import (
-    transactional,
-    version_class,
-    VersionOptions,
-)
 from app.dao.email_branding_dao import dao_get_email_branding_by_name
 from app.dao.letter_branding_dao import dao_get_letter_branding_by_name
 from app.dao.organisation_dao import dao_get_organisation_by_email_address
@@ -20,6 +16,17 @@ from app.dao.service_sms_sender_dao import insert_service_sms_sender
 from app.dao.service_user_dao import dao_get_service_user
 from app.dao.template_folder_dao import dao_get_valid_template_folders_by_id
 from app.models import (
+    CROWN_ORGANISATION_TYPES,
+    EMAIL_TYPE,
+    INTERNATIONAL_LETTERS,
+    INTERNATIONAL_SMS_TYPE,
+    KEY_TYPE_TEST,
+    LETTER_TYPE,
+    NHS_ORGANISATION_TYPES,
+    NON_CROWN_ORGANISATION_TYPES,
+    NOTIFICATION_PERMANENT_FAILURE,
+    SMS_TYPE,
+    UPLOAD_LETTERS,
     AnnualBilling,
     ApiKey,
     FactBilling,
@@ -31,27 +38,16 @@ from app.models import (
     Organisation,
     Permission,
     Service,
+    ServiceContactList,
+    ServiceEmailReplyTo,
+    ServiceLetterContact,
     ServicePermission,
     ServiceSmsSender,
-    ServiceEmailReplyTo,
-    ServiceContactList,
-    ServiceLetterContact,
     Template,
     TemplateHistory,
     TemplateRedacted,
     User,
     VerifyCode,
-    CROWN_ORGANISATION_TYPES,
-    EMAIL_TYPE,
-    INTERNATIONAL_SMS_TYPE,
-    KEY_TYPE_TEST,
-    NHS_ORGANISATION_TYPES,
-    NON_CROWN_ORGANISATION_TYPES,
-    NOTIFICATION_PERMANENT_FAILURE,
-    SMS_TYPE,
-    LETTER_TYPE,
-    UPLOAD_LETTERS,
-    INTERNATIONAL_LETTERS
 )
 from app.utils import (
     email_address_is_nhs,

app/dao/templates_dao.py

@@ -1,23 +1,19 @@
-from datetime import datetime
 import uuid
+from datetime import datetime
 
 from flask import current_app
 from sqlalchemy import asc, desc
 
 from app import db
+from app.dao.dao_utils import VersionOptions, transactional, version_class
+from app.dao.users_dao import get_user_by_id
 from app.models import (
     LETTER_TYPE,
     SECOND_CLASS,
     Template,
     TemplateHistory,
-    TemplateRedacted
+    TemplateRedacted,
 )
-from app.dao.dao_utils import (
-    transactional,
-    version_class,
-    VersionOptions,
-)
-from app.dao.users_dao import get_user_by_id
 
 
 @transactional

app/dao/uploads_dao.py

@@ -1,11 +1,18 @@
 from datetime import datetime
+
 from flask import current_app
-from sqlalchemy import and_, desc, func, literal, text, String
+from sqlalchemy import String, and_, desc, func, literal, text
 
 from app import db
 from app.models import (
-    Job, Notification, Template, LETTER_TYPE, JOB_STATUS_CANCELLED, JOB_STATUS_SCHEDULED,
-    NOTIFICATION_CANCELLED, ServiceDataRetention
+    JOB_STATUS_CANCELLED,
+    JOB_STATUS_SCHEDULED,
+    LETTER_TYPE,
+    NOTIFICATION_CANCELLED,
+    Job,
+    Notification,
+    ServiceDataRetention,
+    Template,
 )
 from app.utils import midnight_n_days_ago
 

app/dao/users_dao.py

@@ -1,16 +1,16 @@
-from random import (SystemRandom)
-from datetime import (datetime, timedelta)
 import uuid
+from datetime import datetime, timedelta
+from random import SystemRandom
 
 from sqlalchemy import func
 from sqlalchemy.orm import joinedload
 
 from app import db
+from app.dao.dao_utils import transactional
 from app.dao.permissions_dao import permission_dao
 from app.dao.service_user_dao import dao_get_service_users_by_user_id
-from app.dao.dao_utils import transactional
 from app.errors import InvalidRequest
-from app.models import (EMAIL_AUTH_TYPE, User, VerifyCode)
+from app.models import EMAIL_AUTH_TYPE, User, VerifyCode
 from app.utils import escape_special_characters, get_archived_db_column_value
 
 

app/delivery/send_to_providers.py

@@ -1,33 +1,39 @@
 import random
-from urllib import parse
 from datetime import datetime, timedelta
+from urllib import parse
+
 from cachetools import TTLCache, cached
 from flask import current_app
-from notifications_utils.template import HTMLEmailTemplate, PlainTextEmailTemplate, SMSMessageTemplate
+from notifications_utils.template import (
+    HTMLEmailTemplate,
+    PlainTextEmailTemplate,
+    SMSMessageTemplate,
+)
 
-from app import notification_provider_clients, statsd_client, create_uuid
+from app import create_uuid, notification_provider_clients, statsd_client
+from app.celery.research_mode_tasks import (
+    send_email_response,
+    send_sms_response,
+)
 from app.dao.email_branding_dao import dao_get_email_branding_by_id
-from app.dao.notifications_dao import (
-    dao_update_notification
-)
+from app.dao.notifications_dao import dao_update_notification
 from app.dao.provider_details_dao import (
+    dao_reduce_sms_provider_priority,
     get_provider_details_by_notification_type,
-    dao_reduce_sms_provider_priority
 )
-from app.celery.research_mode_tasks import send_sms_response, send_email_response
 from app.exceptions import NotificationTechnicalFailureException
 from app.models import (
-    SMS_TYPE,
-    KEY_TYPE_TEST,
     BRANDING_BOTH,
     BRANDING_ORG_BANNER,
     EMAIL_TYPE,
-    NOTIFICATION_TECHNICAL_FAILURE,
-    NOTIFICATION_SENT,
+    KEY_TYPE_TEST,
     NOTIFICATION_SENDING,
-    NOTIFICATION_STATUS_TYPES_COMPLETED
+    NOTIFICATION_SENT,
+    NOTIFICATION_STATUS_TYPES_COMPLETED,
+    NOTIFICATION_TECHNICAL_FAILURE,
+    SMS_TYPE,
 )
-from app.serialised_models import SerialisedTemplate, SerialisedService
+from app.serialised_models import SerialisedService, SerialisedTemplate
 
 
 def send_sms_to_provider(notification):

app/email_branding/rest.py

@@ -2,16 +2,16 @@ from flask import Blueprint, jsonify, request
 
 from app.dao.email_branding_dao import (
     dao_create_email_branding,
-    dao_get_email_branding_options,
     dao_get_email_branding_by_id,
-    dao_update_email_branding
+    dao_get_email_branding_options,
+    dao_update_email_branding,
+)
+from app.email_branding.email_branding_schema import (
+    post_create_email_branding_schema,
+    post_update_email_branding_schema,
 )
 from app.errors import register_errors
 from app.models import EmailBranding
-from app.email_branding.email_branding_schema import (
-    post_create_email_branding_schema,
-    post_update_email_branding_schema
-)
 from app.schema_validation import validate
 
 email_branding_blueprint = Blueprint('email_branding', __name__)

app/errors.py

@@ -1,12 +1,10 @@
-from flask import (
-    jsonify,
-    current_app,
-    json)
+from flask import current_app, json, jsonify
+from jsonschema import ValidationError as JsonSchemaValidationError
+from marshmallow import ValidationError
 from notifications_utils.recipients import InvalidEmailError
 from sqlalchemy.exc import DataError
 from sqlalchemy.orm.exc import NoResultFound
-from marshmallow import ValidationError
-from jsonschema import ValidationError as JsonSchemaValidationError
+
 from app.authentication.auth import AuthError
 from app.exceptions import ArchiveValidationError
 

app/events/rest.py

@@ -1,13 +1,8 @@
-from flask import (
-    Blueprint,
-    jsonify,
-    request
-)
+from flask import Blueprint, jsonify, request
 
-from app.errors import register_errors
-
-from app.schemas import event_schema
 from app.dao.events_dao import dao_create_event
+from app.errors import register_errors
+from app.schemas import event_schema
 
 events = Blueprint('events', __name__, url_prefix='/events')
 register_errors(events)

app/hashing.py

@@ -1,4 +1,4 @@
-from flask_bcrypt import generate_password_hash, check_password_hash
+from flask_bcrypt import check_password_hash, generate_password_hash
 
 
 def hashpw(password):

app/history_meta.py

@@ -15,11 +15,11 @@ session events.
 
 """
 import datetime
+
+from sqlalchemy import Column, ForeignKeyConstraint, Integer, Table, util
 from sqlalchemy.ext.declarative import declared_attr
-from sqlalchemy.orm import mapper, attributes, object_mapper
-from sqlalchemy.orm.properties import RelationshipProperty, ColumnProperty
-from sqlalchemy import Table, Column, ForeignKeyConstraint, Integer
-from sqlalchemy import util
+from sqlalchemy.orm import attributes, mapper, object_mapper
+from sqlalchemy.orm.properties import ColumnProperty, RelationshipProperty
 
 
 def col_references_table(col, table):

app/inbound_number/rest.py

@@ -1,10 +1,10 @@
 from flask import Blueprint, jsonify
 
 from app.dao.inbound_numbers_dao import (
-    dao_get_inbound_numbers,
-    dao_get_inbound_number_for_service,
     dao_get_available_inbound_numbers,
-    dao_set_inbound_number_active_flag
+    dao_get_inbound_number_for_service,
+    dao_get_inbound_numbers,
+    dao_set_inbound_number_active_flag,
 )
 from app.errors import register_errors
 

app/inbound_sms/rest.py

@@ -1,23 +1,21 @@
-from flask import (
-    Blueprint,
-    jsonify,
-    request
-)
-
+from flask import Blueprint, jsonify, request
 from notifications_utils.recipients import try_validate_and_format_phone_number
 
 from app.dao.inbound_sms_dao import (
-    dao_get_inbound_sms_for_service,
     dao_count_inbound_sms_for_service,
     dao_get_inbound_sms_by_id,
-    dao_get_paginated_most_recent_inbound_sms_by_user_number_for_service
+    dao_get_inbound_sms_for_service,
+    dao_get_paginated_most_recent_inbound_sms_by_user_number_for_service,
+)
+from app.dao.service_data_retention_dao import (
+    fetch_service_data_retention_by_notification_type,
 )
-from app.dao.service_data_retention_dao import fetch_service_data_retention_by_notification_type
 from app.errors import register_errors
+from app.inbound_sms.inbound_sms_schemas import (
+    get_inbound_sms_for_service_schema,
+)
 from app.schema_validation import validate
 
-from app.inbound_sms.inbound_sms_schemas import get_inbound_sms_for_service_schema
-
 inbound_sms = Blueprint(
     'inbound_sms',
     __name__,

app/invite/rest.py

@@ -1,20 +1,19 @@
-from flask import (
-    Blueprint,
-    request,
-    jsonify,
-    current_app)
+from flask import Blueprint, current_app, jsonify, request
 
 from app.config import QueueNames
 from app.dao.invited_user_dao import (
-    save_invited_user,
     get_invited_user,
-    get_invited_users_for_service
+    get_invited_users_for_service,
+    save_invited_user,
 )
 from app.dao.templates_dao import dao_get_template_by_id
-from app.models import BROADCAST_TYPE, EMAIL_TYPE, KEY_TYPE_NORMAL, Service
-from app.notifications.process_notifications import persist_notification, send_notification_to_queue
-from app.schemas import invited_user_schema
 from app.errors import register_errors
+from app.models import BROADCAST_TYPE, EMAIL_TYPE, KEY_TYPE_NORMAL, Service
+from app.notifications.process_notifications import (
+    persist_notification,
+    send_notification_to_queue,
+)
+from app.schemas import invited_user_schema
 
 invite = Blueprint('invite', __name__, url_prefix='/service/<service_id>/invite')
 

app/job/rest.py

@@ -1,43 +1,44 @@
 import dateutil
 import pytz
-from flask import (
-    Blueprint,
-    jsonify,
-    request,
-    current_app
-)
+from flask import Blueprint, current_app, jsonify, request
 
 from app.aws.s3 import get_job_metadata_from_s3
+from app.celery.tasks import process_job
+from app.config import QueueNames
+from app.dao.fact_notification_status_dao import (
+    fetch_notification_statuses_for_job,
+)
 from app.dao.jobs_dao import (
+    can_letter_job_be_cancelled,
+    dao_cancel_letter_job,
     dao_create_job,
-    dao_update_job,
+    dao_get_future_scheduled_job_by_id_and_service_id,
     dao_get_job_by_service_id_and_job_id,
     dao_get_jobs_by_service_id,
-    dao_get_future_scheduled_job_by_id_and_service_id,
     dao_get_notification_outcomes_for_job,
     dao_get_scheduled_job_stats,
-    dao_cancel_letter_job,
-    can_letter_job_be_cancelled
+    dao_update_job,
+)
+from app.dao.notifications_dao import (
+    dao_get_notification_count_for_job_id,
+    get_notifications_for_job,
 )
-from app.dao.fact_notification_status_dao import fetch_notification_statuses_for_job
 from app.dao.services_dao import dao_fetch_service_by_id
 from app.dao.templates_dao import dao_get_template_by_id
-from app.dao.notifications_dao import dao_get_notification_count_for_job_id, get_notifications_for_job
+from app.errors import InvalidRequest, register_errors
+from app.models import (
+    JOB_STATUS_CANCELLED,
+    JOB_STATUS_PENDING,
+    JOB_STATUS_SCHEDULED,
+    LETTER_TYPE,
+)
 from app.schemas import (
     job_schema,
-    unarchived_template_schema,
+    notification_with_template_schema,
     notifications_filter_schema,
-    notification_with_template_schema
+    unarchived_template_schema,
 )
-from app.celery.tasks import process_job
-from app.models import JOB_STATUS_SCHEDULED, JOB_STATUS_PENDING, JOB_STATUS_CANCELLED, LETTER_TYPE
-from app.utils import pagination_links, midnight_n_days_ago
-from app.config import QueueNames
-from app.errors import (
-    register_errors,
-    InvalidRequest
-)
-
+from app.utils import midnight_n_days_ago, pagination_links
 
 job_blueprint = Blueprint('job', __name__, url_prefix='/service/<uuid:service_id>/job')
 

app/letter_branding/letter_branding_rest.py

@@ -1,15 +1,17 @@
 from celery import current_app
+from flask import Blueprint, jsonify, request
 from sqlalchemy.exc import IntegrityError
 
-from flask import Blueprint, jsonify, request
-
 from app.dao.letter_branding_dao import (
-    dao_get_all_letter_branding, dao_create_letter_branding,
+    dao_create_letter_branding,
+    dao_get_all_letter_branding,
+    dao_get_letter_branding_by_id,
     dao_update_letter_branding,
-    dao_get_letter_branding_by_id
 )
 from app.errors import register_errors
-from app.letter_branding.letter_branding_schema import post_letter_branding_schema
+from app.letter_branding.letter_branding_schema import (
+    post_letter_branding_schema,
+)
 from app.models import LetterBranding
 from app.schema_validation import validate
 

app/letters/rest.py

@@ -1,5 +1,4 @@
-from flask import Blueprint, jsonify
-from flask import request
+from flask import Blueprint, jsonify, request
 
 from app.celery.tasks import process_returned_letters_list
 from app.config import QueueNames

app/letters/utils.py

@@ -1,20 +1,23 @@
-import boto3
 import io
 import json
 import math
-
-from app.models import KEY_TYPE_TEST, SECOND_CLASS, RESOLVE_POSTAGE_FOR_FILE_NAME, NOTIFICATION_VALIDATION_FAILED
-
 from datetime import datetime, timedelta
 from enum import Enum
 
+import boto3
 from flask import current_app
-
 from notifications_utils.letter_timings import LETTER_PROCESSING_DEADLINE
 from notifications_utils.pdf import pdf_page_count
 from notifications_utils.s3 import s3upload
 from notifications_utils.timezones import convert_utc_to_bst
 
+from app.models import (
+    KEY_TYPE_TEST,
+    NOTIFICATION_VALIDATION_FAILED,
+    RESOLVE_POSTAGE_FOR_FILE_NAME,
+    SECOND_CLASS,
+)
+
 
 class ScanErrorType(Enum):
     ERROR = 1

app/models.py

@@ -1,41 +1,42 @@
+import datetime
 import itertools
 import uuid
-import datetime
-from flask import url_for, current_app
 
-from sqlalchemy.ext.declarative import declared_attr
-from sqlalchemy.ext.associationproxy import association_proxy
-from sqlalchemy.ext.hybrid import hybrid_property
-from sqlalchemy.schema import Sequence
-from sqlalchemy.dialects.postgresql import (
-    UUID,
-    JSON,
-    JSONB,
-)
-from sqlalchemy.orm.collections import attribute_mapped_collection
-from sqlalchemy import UniqueConstraint, CheckConstraint, Index, String, and_, func
+from flask import current_app, url_for
 from notifications_utils.columns import Columns
+from notifications_utils.letter_timings import get_letter_timings
 from notifications_utils.recipients import (
+    InvalidEmailError,
+    InvalidPhoneError,
+    try_validate_and_format_phone_number,
     validate_email_address,
     validate_phone_number,
-    try_validate_and_format_phone_number,
-    InvalidPhoneError,
-    InvalidEmailError
 )
-from notifications_utils.letter_timings import get_letter_timings
 from notifications_utils.template import (
+    BroadcastMessageTemplate,
+    LetterPrintTemplate,
     PlainTextEmailTemplate,
     SMSMessageTemplate,
-    LetterPrintTemplate,
-    BroadcastMessageTemplate,
 )
 from notifications_utils.timezones import convert_utc_to_bst
-
-from app.hashing import (
-    hashpw,
-    check_hash
+from sqlalchemy import (
+    CheckConstraint,
+    Index,
+    String,
+    UniqueConstraint,
+    and_,
+    func,
 )
+from sqlalchemy.dialects.postgresql import JSON, JSONB, UUID
+from sqlalchemy.ext.associationproxy import association_proxy
+from sqlalchemy.ext.declarative import declared_attr
+from sqlalchemy.ext.hybrid import hybrid_property
+from sqlalchemy.orm.collections import attribute_mapped_collection
+from sqlalchemy.schema import Sequence
+
 from app import db, encryption
+from app.hashing import check_hash, hashpw
+from app.history_meta import Versioned
 from app.utils import (
     DATETIME_FORMAT,
     DATETIME_FORMAT_NO_TIMEZONE,
@@ -43,8 +44,6 @@ from app.utils import (
     get_uuid_string_or_none,
 )
 
-from app.history_meta import Versioned
-
 SMS_TYPE = 'sms'
 EMAIL_TYPE = 'email'
 LETTER_TYPE = 'letter'
@@ -2437,7 +2436,9 @@ class BroadcastEvent(db.Model):
         Return the full provider_message object rather than just an identifier, since the different providers expect
         reference to contain different things - let the cbc_proxy work out what information is relevant.
         """
-        from app.dao.broadcast_message_dao import get_earlier_events_for_broadcast_event
+        from app.dao.broadcast_message_dao import (
+            get_earlier_events_for_broadcast_event,
+        )
         earlier_events = [
             event for event in get_earlier_events_for_broadcast_event(self.id)
         ]

app/notifications/notifications_letter_callback.py

@@ -1,19 +1,16 @@
 import json
-
 from functools import wraps
 
-from flask import (
-    Blueprint,
-    jsonify,
-    request,
-    current_app
-)
+from flask import Blueprint, current_app, jsonify, request
 
-from app.celery.tasks import update_letter_notifications_statuses, record_daily_sorted_counts
-from app.v2.errors import register_errors
+from app.celery.tasks import (
+    record_daily_sorted_counts,
+    update_letter_notifications_statuses,
+)
+from app.config import QueueNames
 from app.notifications.utils import autoconfirm_subscription
 from app.schema_validation import validate
-from app.config import QueueNames
+from app.v2.errors import register_errors
 
 letter_callback_blueprint = Blueprint('notifications_letter_callback', __name__)
 register_errors(letter_callback_blueprint)

app/notifications/notifications_ses_callback.py

@@ -1,18 +1,21 @@
 from flask import current_app
 
-from app.dao.complaint_dao import save_complaint
-from app.dao.notifications_dao import dao_get_notification_or_history_by_reference
-from app.dao.service_callback_api_dao import (
-    get_service_delivery_status_callback_api_for_service, get_service_complaint_callback_api_for_service
-)
-from app.models import Complaint
 from app.celery.service_callback_tasks import (
-    send_delivery_status_to_service,
-    send_complaint_to_service,
+    create_complaint_callback_data,
     create_delivery_status_callback_data,
-    create_complaint_callback_data
+    send_complaint_to_service,
+    send_delivery_status_to_service,
 )
 from app.config import QueueNames
+from app.dao.complaint_dao import save_complaint
+from app.dao.notifications_dao import (
+    dao_get_notification_or_history_by_reference,
+)
+from app.dao.service_callback_api_dao import (
+    get_service_complaint_callback_api_for_service,
+    get_service_delivery_status_callback_api_for_service,
+)
+from app.models import Complaint
 
 
 def determine_notification_bounce_type(notification_type, ses_message):

app/notifications/notifications_sms_callback.py

@@ -1,9 +1,8 @@
-from flask import Blueprint
-from flask import current_app
-from flask import json
-from flask import request, jsonify
+from flask import Blueprint, current_app, json, jsonify, request
 
-from app.celery.process_sms_client_response_tasks import process_sms_client_response
+from app.celery.process_sms_client_response_tasks import (
+    process_sms_client_response,
+)
 from app.config import QueueNames
 from app.errors import InvalidRequest, register_errors
 

app/notifications/process_notifications.py

@@ -2,43 +2,38 @@ import uuid
 from datetime import datetime
 
 from flask import current_app
-
+from gds_metrics import Histogram
 from notifications_utils.clients import redis
 from notifications_utils.recipients import (
+    format_email_address,
     get_international_phone_info,
     validate_and_format_phone_number,
-    format_email_address
 )
 from notifications_utils.template import (
+    LetterPrintTemplate,
     PlainTextEmailTemplate,
     SMSMessageTemplate,
-    LetterPrintTemplate,
 )
 
 from app import redis_store
 from app.celery import provider_tasks
 from app.celery.letters_pdf_tasks import get_pdf_for_templated_letter
 from app.config import QueueNames
-
-from app.models import (
-    EMAIL_TYPE,
-    KEY_TYPE_TEST,
-    SMS_TYPE,
-    LETTER_TYPE,
-    NOTIFICATION_CREATED,
-    Notification,
-    INTERNATIONAL_POSTAGE_TYPES)
 from app.dao.notifications_dao import (
     dao_create_notification,
     dao_delete_notifications_by_id,
 )
-
+from app.models import (
+    EMAIL_TYPE,
+    INTERNATIONAL_POSTAGE_TYPES,
+    KEY_TYPE_TEST,
+    LETTER_TYPE,
+    NOTIFICATION_CREATED,
+    SMS_TYPE,
+    Notification,
+)
 from app.v2.errors import BadRequestError
 
-
-from gds_metrics import Histogram
-
-
 REDIS_GET_AND_INCR_DAILY_LIMIT_DURATION_SECONDS = Histogram(
     'redis_get_and_incr_daily_limit_duration_seconds',
     'Time taken to get and possibly incremement the daily limit cache key',

app/notifications/receive_notifications.py

@@ -2,16 +2,16 @@ from datetime import datetime
 from urllib.parse import unquote
 
 import iso8601
-from flask import jsonify, Blueprint, current_app, request, abort
+from flask import Blueprint, abort, current_app, jsonify, request
 from gds_metrics.metrics import Counter
 from notifications_utils.recipients import try_validate_and_format_phone_number
 
 from app.celery import tasks
 from app.config import QueueNames
-from app.dao.services_dao import dao_fetch_service_by_inbound_number
 from app.dao.inbound_sms_dao import dao_create_inbound_sms
-from app.models import InboundSms, INBOUND_SMS_TYPE, SMS_TYPE
+from app.dao.services_dao import dao_fetch_service_by_inbound_number
 from app.errors import register_errors
+from app.models import INBOUND_SMS_TYPE, SMS_TYPE, InboundSms
 
 receive_notifications_blueprint = Blueprint('receive_notifications', __name__)
 register_errors(receive_notifications_blueprint)

app/notifications/rest.py

@@ -1,27 +1,21 @@
-from flask import (
-    Blueprint,
-    jsonify,
-    request,
-    current_app
-)
+from flask import Blueprint, current_app, jsonify, request
+from notifications_utils import SMS_CHAR_COUNT_LIMIT
 
 from app import api_user, authenticated_service
 from app.config import QueueNames
-from app.dao import (
-    notifications_dao
-)
-from app.errors import (
-    register_errors,
-    InvalidRequest
-)
+from app.dao import notifications_dao
+from app.errors import InvalidRequest, register_errors
 from app.models import (
-    EMAIL_TYPE, SMS_TYPE,
-    KEY_TYPE_TEAM, PRIORITY,
-    LETTER_TYPE)
+    EMAIL_TYPE,
+    KEY_TYPE_TEAM,
+    LETTER_TYPE,
+    PRIORITY,
+    SMS_TYPE,
+)
 from app.notifications.process_notifications import (
     persist_notification,
     send_notification_to_queue,
-    simulated_recipient
+    simulated_recipient,
 )
 from app.notifications.validators import (
     check_if_service_can_send_to_number,
@@ -31,14 +25,12 @@ from app.notifications.validators import (
 )
 from app.schemas import (
     email_notification_schema,
-    sms_template_notification_schema,
     notification_with_personalisation_schema,
-    notifications_filter_schema
+    notifications_filter_schema,
+    sms_template_notification_schema,
 )
 from app.service.utils import service_allowed_to_send_to
-from app.utils import pagination_links, get_public_notify_type_text
-
-from notifications_utils import SMS_CHAR_COUNT_LIMIT
+from app.utils import get_public_notify_type_text, pagination_links
 
 notifications = Blueprint('notifications', __name__)
 

app/notifications/utils.py

@@ -1,5 +1,5 @@
-from flask import current_app
 import requests
+from flask import current_app
 
 
 def confirm_subscription(confirmation_request):

app/notifications/validators.py

@@ -1,31 +1,45 @@
-from notifications_utils.postal_address import PostalAddress
-from sqlalchemy.orm.exc import NoResultFound
 from flask import current_app
+from gds_metrics.metrics import Histogram
 from notifications_utils import SMS_CHAR_COUNT_LIMIT
-from notifications_utils.recipients import (
-    validate_and_format_phone_number,
-    validate_and_format_email_address,
-    get_international_phone_info
+from notifications_utils.clients.redis import (
+    daily_limit_cache_key,
+    rate_limit_cache_key,
 )
-from notifications_utils.clients.redis import rate_limit_cache_key, daily_limit_cache_key
+from notifications_utils.postal_address import PostalAddress
+from notifications_utils.recipients import (
+    get_international_phone_info,
+    validate_and_format_email_address,
+    validate_and_format_phone_number,
+)
+from sqlalchemy.orm.exc import NoResultFound
 
-from app.dao import services_dao
-from app.dao.service_sms_sender_dao import dao_get_service_sms_senders_by_id
-from app.models import (
-    INTERNATIONAL_SMS_TYPE, SMS_TYPE, EMAIL_TYPE, LETTER_TYPE,
-    KEY_TYPE_TEST, KEY_TYPE_TEAM,
-    ServicePermission,
-    INTERNATIONAL_LETTERS)
-from app.service.utils import service_allowed_to_send_to
-from app.v2.errors import TooManyRequestsError, BadRequestError, RateLimitError, ValidationError
 from app import redis_store
-from app.notifications.process_notifications import create_content_for_notification
-from app.utils import get_public_notify_type_text
+from app.dao import services_dao
 from app.dao.service_email_reply_to_dao import dao_get_reply_to_by_id
 from app.dao.service_letter_contact_dao import dao_get_letter_contact_by_id
+from app.dao.service_sms_sender_dao import dao_get_service_sms_senders_by_id
+from app.models import (
+    EMAIL_TYPE,
+    INTERNATIONAL_LETTERS,
+    INTERNATIONAL_SMS_TYPE,
+    KEY_TYPE_TEAM,
+    KEY_TYPE_TEST,
+    LETTER_TYPE,
+    SMS_TYPE,
+    ServicePermission,
+)
+from app.notifications.process_notifications import (
+    create_content_for_notification,
+)
 from app.serialised_models import SerialisedTemplate
-
-from gds_metrics.metrics import Histogram
+from app.service.utils import service_allowed_to_send_to
+from app.utils import get_public_notify_type_text
+from app.v2.errors import (
+    BadRequestError,
+    RateLimitError,
+    TooManyRequestsError,
+    ValidationError,
+)
 
 REDIS_EXCEEDED_RATE_LIMIT_DURATION_SECONDS = Histogram(
     'redis_exceeded_rate_limit_duration_seconds',

app/organisation/invite_rest.py

@@ -1,25 +1,24 @@
-from flask import (
-    Blueprint,
-    request,
-    jsonify,
-    current_app)
+from flask import Blueprint, current_app, jsonify, request
 from notifications_utils.url_safe_token import generate_token
 
 from app.config import QueueNames
 from app.dao.invited_org_user_dao import (
-    save_invited_org_user,
     get_invited_org_user,
-    get_invited_org_users_for_organisation
+    get_invited_org_users_for_organisation,
+    save_invited_org_user,
 )
 from app.dao.templates_dao import dao_get_template_by_id
 from app.errors import register_errors
 from app.models import EMAIL_TYPE, KEY_TYPE_NORMAL, InvitedOrganisationUser
-from app.notifications.process_notifications import persist_notification, send_notification_to_queue
-from app.schema_validation import validate
+from app.notifications.process_notifications import (
+    persist_notification,
+    send_notification_to_queue,
+)
 from app.organisation.organisation_schema import (
     post_create_invited_org_user_status_schema,
-    post_update_invited_org_user_status_schema
+    post_update_invited_org_user_status_schema,
 )
+from app.schema_validation import validate
 
 organisation_invite_blueprint = Blueprint(
     'organisation_invite', __name__,

app/organisation/rest.py

@@ -1,29 +1,32 @@
 
-from flask import abort, Blueprint, jsonify, request, current_app
+from flask import Blueprint, abort, current_app, jsonify, request
 from sqlalchemy.exc import IntegrityError
 
 from app.config import QueueNames
 from app.dao.fact_billing_dao import fetch_usage_year_for_organisation
 from app.dao.organisation_dao import (
-    dao_create_organisation,
-    dao_get_organisations,
-    dao_get_organisation_by_id,
-    dao_get_organisation_by_email_address,
-    dao_get_organisation_services,
-    dao_update_organisation,
     dao_add_service_to_organisation,
+    dao_add_user_to_organisation,
+    dao_create_organisation,
+    dao_get_organisation_by_email_address,
+    dao_get_organisation_by_id,
+    dao_get_organisation_services,
+    dao_get_organisations,
     dao_get_users_for_organisation,
-    dao_add_user_to_organisation
+    dao_update_organisation,
 )
-from app.dao.templates_dao import dao_get_template_by_id
 from app.dao.services_dao import dao_fetch_service_by_id
-from app.errors import register_errors, InvalidRequest
-from app.models import Organisation, KEY_TYPE_NORMAL
-from app.notifications.process_notifications import persist_notification, send_notification_to_queue
+from app.dao.templates_dao import dao_get_template_by_id
+from app.errors import InvalidRequest, register_errors
+from app.models import KEY_TYPE_NORMAL, Organisation
+from app.notifications.process_notifications import (
+    persist_notification,
+    send_notification_to_queue,
+)
 from app.organisation.organisation_schema import (
     post_create_organisation_schema,
-    post_update_organisation_schema,
     post_link_service_to_organisation_schema,
+    post_update_organisation_schema,
 )
 from app.schema_validation import validate
 

app/performance_dashboard/rest.py

@@ -1,12 +1,18 @@
 from datetime import datetime
 
-from flask import Blueprint, request, jsonify
+from flask import Blueprint, jsonify, request
 
-from app.dao.fact_notification_status_dao import get_total_notifications_for_date_range
-from app.dao.fact_processing_time_dao import get_processing_time_percentage_for_date_range
+from app.dao.fact_notification_status_dao import (
+    get_total_notifications_for_date_range,
+)
+from app.dao.fact_processing_time_dao import (
+    get_processing_time_percentage_for_date_range,
+)
 from app.dao.services_dao import get_live_services_with_organisation
 from app.errors import register_errors
-from app.performance_dashboard.performance_dashboard_schema import performance_dashboard_request
+from app.performance_dashboard.performance_dashboard_schema import (
+    performance_dashboard_request,
+)
 from app.schema_validation import validate
 
 performance_dashboard_blueprint = Blueprint('performance_dashboard', __name__, url_prefix='/performance-dashboard')

app/performance_platform/processing_time.py

@@ -2,11 +2,13 @@ from datetime import timedelta
 
 from flask import current_app
 
+from app import performance_platform_client
 from app.dao.fact_processing_time_dao import insert_update_processing_time
+from app.dao.notifications_dao import (
+    dao_get_total_notifications_sent_per_day_for_performance_platform,
+)
 from app.models import FactProcessingTime
 from app.utils import get_london_midnight_in_utc
-from app.dao.notifications_dao import dao_get_total_notifications_sent_per_day_for_performance_platform
-from app import performance_platform_client
 
 
 def send_processing_time_to_performance_platform(bst_date):

app/performance_platform/total_sent_notifications.py

@@ -1,5 +1,7 @@
 from app import performance_platform_client
-from app.dao.fact_notification_status_dao import get_total_sent_notifications_for_day_and_type
+from app.dao.fact_notification_status_dao import (
+    get_total_sent_notifications_for_day_and_type,
+)
 
 
 def send_total_notifications_sent_for_day_stats(start_time, notification_type, count):

app/platform_stats/rest.py

@@ -4,15 +4,18 @@ from flask import Blueprint, jsonify, request
 
 from app.dao.date_util import get_financial_year_for_datetime
 from app.dao.fact_billing_dao import (
-    fetch_sms_billing_for_all_services, fetch_letter_costs_for_all_services,
-    fetch_letter_line_items_for_all_services
+    fetch_letter_costs_for_all_services,
+    fetch_letter_line_items_for_all_services,
+    fetch_sms_billing_for_all_services,
 )
-from app.dao.fact_notification_status_dao import fetch_notification_status_totals_for_all_services
-from app.errors import register_errors, InvalidRequest
+from app.dao.fact_notification_status_dao import (
+    fetch_notification_status_totals_for_all_services,
+)
+from app.errors import InvalidRequest, register_errors
 from app.models import UK_POSTAGE_TYPES
 from app.platform_stats.platform_stats_schema import platform_stats_request
-from app.service.statistics import format_admin_stats
 from app.schema_validation import validate
+from app.service.statistics import format_admin_stats
 from app.utils import get_london_midnight_in_utc
 
 platform_stats_blueprint = Blueprint('platform_stats', __name__)

app/provider_details/rest.py

@@ -1,17 +1,14 @@
 from flask import Blueprint, jsonify, request
 
-from app.schemas import provider_details_schema, provider_details_history_schema
 from app.dao.provider_details_dao import (
-    get_provider_details_by_id,
-    dao_update_provider_details,
     dao_get_provider_stats,
-    dao_get_provider_versions
+    dao_get_provider_versions,
+    dao_update_provider_details,
+    get_provider_details_by_id,
 )
 from app.dao.users_dao import get_user_by_id
-from app.errors import (
-    register_errors,
-    InvalidRequest
-)
+from app.errors import InvalidRequest, register_errors
+from app.schemas import provider_details_history_schema, provider_details_schema
 
 provider_details = Blueprint('provider_details', __name__)
 register_errors(provider_details)

app/schema_validation/__init__.py

@@ -2,10 +2,14 @@ import json
 from datetime import datetime, timedelta
 from uuid import UUID
 
-from iso8601 import iso8601, ParseError
-from jsonschema import (Draft7Validator, ValidationError, FormatChecker)
-from notifications_utils.recipients import (validate_phone_number, validate_email_address, InvalidPhoneError,
-                                            InvalidEmailError)
+from iso8601 import ParseError, iso8601
+from jsonschema import Draft7Validator, FormatChecker, ValidationError
+from notifications_utils.recipients import (
+    InvalidEmailError,
+    InvalidPhoneError,
+    validate_email_address,
+    validate_phone_number,
+)
 
 format_checker = FormatChecker()
 

app/schemas.py

@@ -1,32 +1,28 @@
-from datetime import (
-    datetime,
-    date,
-    timedelta)
-from flask_marshmallow.fields import fields
-from marshmallow import (
-    post_load,
-    ValidationError,
-    validates,
-    validates_schema,
-    pre_load,
-    pre_dump,
-    post_dump
-)
-from marshmallow_sqlalchemy import field_for
+from datetime import date, datetime, timedelta
 from uuid import UUID
 
+from flask_marshmallow.fields import fields
+from marshmallow import (
+    ValidationError,
+    post_dump,
+    post_load,
+    pre_dump,
+    pre_load,
+    validates,
+    validates_schema,
+)
+from marshmallow_sqlalchemy import field_for
 from notifications_utils.recipients import (
-    validate_email_address,
     InvalidEmailError,
-    validate_phone_number,
     InvalidPhoneError,
-    validate_and_format_phone_number
+    validate_and_format_phone_number,
+    validate_email_address,
+    validate_phone_number,
 )
 
-from app import ma
-from app import models
-from app.models import ServicePermission
+from app import ma, models
 from app.dao.permissions_dao import permission_dao
+from app.models import ServicePermission
 from app.utils import DATETIME_FORMAT_NO_TIMEZONE, get_template_instance
 
 

app/serialised_models.py

@@ -11,7 +11,6 @@ from notifications_utils.serialised_model import (
 from werkzeug.utils import cached_property
 
 from app import db, redis_store
-
 from app.dao.api_key_dao import get_model_api_keys
 from app.dao.services_dao import dao_fetch_service_by_id
 

app/service/callback_rest.py

@@ -1,35 +1,28 @@
-from flask import (
-    Blueprint,
-    jsonify,
-    request,
-)
+from flask import Blueprint, jsonify, request
 from sqlalchemy.exc import SQLAlchemyError
 
-from app.errors import (
-    register_errors,
-    InvalidRequest
+from app.dao.service_callback_api_dao import (
+    delete_service_callback_api,
+    get_service_callback_api,
+    reset_service_callback_api,
+    save_service_callback_api,
 )
+from app.dao.service_inbound_api_dao import (
+    delete_service_inbound_api,
+    get_service_inbound_api,
+    reset_service_inbound_api,
+    save_service_inbound_api,
+)
+from app.errors import InvalidRequest, register_errors
 from app.models import (
-    ServiceInboundApi,
-    ServiceCallbackApi,
     DELIVERY_STATUS_CALLBACK_TYPE,
+    ServiceCallbackApi,
+    ServiceInboundApi,
 )
 from app.schema_validation import validate
 from app.service.service_callback_api_schema import (
     create_service_callback_api_schema,
-    update_service_callback_api_schema
-)
-from app.dao.service_inbound_api_dao import (
-    save_service_inbound_api,
-    get_service_inbound_api,
-    reset_service_inbound_api,
-    delete_service_inbound_api,
-)
-from app.dao.service_callback_api_dao import (
-    save_service_callback_api,
-    get_service_callback_api,
-    reset_service_callback_api,
-    delete_service_callback_api,
+    update_service_callback_api_schema,
 )
 
 service_callback_blueprint = Blueprint('service_callback', __name__, url_prefix='/service/<uuid:service_id>')

app/service/rest.py

@@ -1,12 +1,7 @@
 import itertools
 from datetime import datetime
 
-from flask import (
-    jsonify,
-    request,
-    current_app,
-    Blueprint
-)
+from flask import Blueprint, current_app, jsonify, request
 from notifications_utils.letter_timings import letter_can_be_cancelled
 from notifications_utils.timezones import convert_utc_to_bst
 from sqlalchemy.exc import IntegrityError
@@ -15,23 +10,24 @@ from sqlalchemy.orm.exc import NoResultFound
 from app.aws import s3
 from app.config import QueueNames
 from app.dao import fact_notification_status_dao, notifications_dao
-from app.dao.dao_utils import dao_rollback
-from app.dao.date_util import get_financial_year
 from app.dao.api_key_dao import (
-    save_model_api_key,
+    expire_api_key,
     get_model_api_keys,
     get_unsigned_secret,
-    expire_api_key)
+    save_model_api_key,
+)
+from app.dao.broadcast_service_dao import set_broadcast_service_type
+from app.dao.dao_utils import dao_rollback
+from app.dao.date_util import get_financial_year
 from app.dao.fact_notification_status_dao import (
+    fetch_monthly_template_usage_for_service,
     fetch_notification_status_for_service_by_month,
     fetch_notification_status_for_service_for_day,
     fetch_notification_status_for_service_for_today_and_7_previous_days,
-    fetch_stats_for_all_services_by_date_range, fetch_monthly_template_usage_for_service
+    fetch_stats_for_all_services_by_date_range,
 )
 from app.dao.inbound_numbers_dao import dao_allocate_number_for_service
-from app.dao.organisation_dao import (
-    dao_get_organisation_by_service_id,
-)
+from app.dao.organisation_dao import dao_get_organisation_by_service_id
 from app.dao.returned_letters_dao import (
     fetch_most_recent_returned_letter,
     fetch_recent_returned_letter_count,
@@ -40,11 +36,10 @@ from app.dao.returned_letters_dao import (
 )
 from app.dao.service_contact_list_dao import (
     dao_archive_contact_list,
-    dao_get_contact_lists,
     dao_get_contact_list_by_id,
+    dao_get_contact_lists,
     save_service_contact_list,
 )
-from app.dao.broadcast_service_dao import set_broadcast_service_type
 from app.dao.service_data_retention_dao import (
     fetch_service_data_retention,
     fetch_service_data_retention_by_id,
@@ -52,13 +47,32 @@ from app.dao.service_data_retention_dao import (
     insert_service_data_retention,
     update_service_data_retention,
 )
+from app.dao.service_email_reply_to_dao import (
+    add_reply_to_email_address_for_service,
+    archive_reply_to_email_address,
+    dao_get_reply_to_by_id,
+    dao_get_reply_to_by_service_id,
+    update_reply_to_email_address,
+)
+from app.dao.service_guest_list_dao import (
+    dao_add_and_commit_guest_list_contacts,
+    dao_fetch_service_guest_list,
+    dao_remove_service_guest_list,
+)
+from app.dao.service_letter_contact_dao import (
+    add_letter_contact_for_service,
+    archive_letter_contact,
+    dao_get_letter_contact_by_id,
+    dao_get_letter_contacts_by_service_id,
+    update_letter_contact,
+)
 from app.dao.service_sms_sender_dao import (
     archive_sms_sender,
     dao_add_sms_sender_for_service,
-    dao_update_service_sms_sender,
     dao_get_service_sms_senders_by_id,
     dao_get_sms_senders_by_service_id,
-    update_existing_sms_sender_with_inbound_number
+    dao_update_service_sms_sender,
+    update_existing_sms_sender_with_inbound_number,
 )
 from app.dao.services_dao import (
     dao_add_user_to_service,
@@ -68,78 +82,71 @@ from app.dao.services_dao import (
     dao_fetch_all_services_by_user,
     dao_fetch_live_services_data,
     dao_fetch_service_by_id,
-    dao_fetch_todays_stats_for_service,
     dao_fetch_todays_stats_for_all_services,
-    dao_resume_service,
+    dao_fetch_todays_stats_for_service,
     dao_remove_user_from_service,
+    dao_resume_service,
     dao_suspend_service,
     dao_update_service,
     get_services_by_partial_name,
 )
-from app.dao.service_guest_list_dao import (
-    dao_fetch_service_guest_list,
-    dao_add_and_commit_guest_list_contacts,
-    dao_remove_service_guest_list
-)
-from app.dao.service_email_reply_to_dao import (
-    add_reply_to_email_address_for_service,
-    archive_reply_to_email_address,
-    dao_get_reply_to_by_id,
-    dao_get_reply_to_by_service_id,
-    update_reply_to_email_address
-)
-from app.dao.service_letter_contact_dao import (
-    archive_letter_contact,
-    dao_get_letter_contacts_by_service_id,
-    dao_get_letter_contact_by_id,
-    add_letter_contact_for_service,
-    update_letter_contact
-)
 from app.dao.templates_dao import dao_get_template_by_id
 from app.dao.users_dao import get_user_by_id
-from app.errors import (
-    InvalidRequest,
-    register_errors
-)
+from app.errors import InvalidRequest, register_errors
 from app.letters.utils import letter_print_day
 from app.models import (
     KEY_TYPE_NORMAL,
     LETTER_TYPE,
     NOTIFICATION_CANCELLED,
-    Permission,
-    Service,
     EmailBranding,
     LetterBranding,
-    ServiceContactList
+    Permission,
+    Service,
+    ServiceContactList,
+)
+from app.notifications.process_notifications import (
+    persist_notification,
+    send_notification_to_queue,
 )
-from app.notifications.process_notifications import persist_notification, send_notification_to_queue
 from app.schema_validation import validate
+from app.schemas import (
+    api_key_schema,
+    detailed_service_schema,
+    email_data_request_schema,
+    notification_with_template_schema,
+    notifications_filter_schema,
+    service_schema,
+)
 from app.service import statistics
+from app.service.send_notification import (
+    send_one_off_notification,
+    send_pdf_letter_notification,
+)
 from app.service.send_pdf_letter_schema import send_pdf_letter_request
-from app.service.service_contact_list_schema import create_service_contact_list_schema
+from app.service.sender import send_notification_to_service_users
+from app.service.service_broadcast_settings_schema import (
+    service_broadcast_settings_schema,
+)
+from app.service.service_contact_list_schema import (
+    create_service_contact_list_schema,
+)
 from app.service.service_data_retention_schema import (
     add_service_data_retention_request,
-    update_service_data_retention_request
+    update_service_data_retention_request,
 )
 from app.service.service_senders_schema import (
     add_service_email_reply_to_request,
     add_service_letter_contact_block_request,
-    add_service_sms_sender_request
+    add_service_sms_sender_request,
 )
-from app.service.service_broadcast_settings_schema import service_broadcast_settings_schema
 from app.service.utils import get_guest_list_objects
-from app.service.sender import send_notification_to_service_users
-from app.service.send_notification import send_one_off_notification, send_pdf_letter_notification
-from app.schemas import (
-    service_schema,
-    api_key_schema,
-    notification_with_template_schema,
-    notifications_filter_schema,
-    detailed_service_schema,
-    email_data_request_schema
-)
 from app.user.users_schema import post_set_permissions_schema
-from app.utils import DATE_FORMAT, DATETIME_FORMAT_NO_TIMEZONE, midnight_n_days_ago, pagination_links
+from app.utils import (
+    DATE_FORMAT,
+    DATETIME_FORMAT_NO_TIMEZONE,
+    midnight_n_days_ago,
+    pagination_links,
+)
 
 service_blueprint = Blueprint('service', __name__)
 
@@ -367,11 +374,11 @@ def remove_user_from_service(service_id, user_id):
 # tables. This is so product owner can pass stories as done
 @service_blueprint.route('/<uuid:service_id>/history', methods=['GET'])
 def get_service_history(service_id):
-    from app.models import (Service, ApiKey, TemplateHistory)
+    from app.models import ApiKey, Service, TemplateHistory
     from app.schemas import (
-        service_history_schema,
         api_key_history_schema,
-        template_history_schema
+        service_history_schema,
+        template_history_schema,
     )
 
     service_history = Service.get_history_model().query.filter_by(id=service_id).all()
@@ -570,7 +577,7 @@ def get_detailed_services(start_date, end_date, only_active=False, include_from_
 
 @service_blueprint.route('/<uuid:service_id>/guest-list', methods=['GET'])
 def get_guest_list(service_id):
-    from app.models import (EMAIL_TYPE, MOBILE_TYPE)
+    from app.models import EMAIL_TYPE, MOBILE_TYPE
     service = dao_fetch_service_by_id(service_id)
 
     if not service:

app/service/send_notification.py

@@ -1,7 +1,8 @@
 import urllib
 
 from flask import current_app
-from notifications_utils.s3 import S3ObjectNotFound, s3download as utils_s3download
+from notifications_utils.s3 import S3ObjectNotFound
+from notifications_utils.s3 import s3download as utils_s3download
 from sqlalchemy.orm.exc import NoResultFound
 
 from app import create_random_identifier
@@ -9,26 +10,11 @@ from app.config import QueueNames
 from app.dao.notifications_dao import _update_notification_status
 from app.dao.service_email_reply_to_dao import dao_get_reply_to_by_id
 from app.dao.service_sms_sender_dao import dao_get_service_sms_senders_by_id
-from app.notifications.validators import (
-    check_service_has_permission,
-    check_service_over_daily_message_limit,
-    validate_and_format_recipient,
-    validate_template,
-    validate_address)
-from app.notifications.process_notifications import (
-    persist_notification,
-    send_notification_to_queue
-)
-from app.models import (
-    KEY_TYPE_NORMAL,
-    PRIORITY,
-    SMS_TYPE,
-    EMAIL_TYPE,
-    LETTER_TYPE,
-    NOTIFICATION_DELIVERED,
-)
 from app.dao.services_dao import dao_fetch_service_by_id
-from app.dao.templates_dao import dao_get_template_by_id_and_service_id, get_precompiled_letter_template
+from app.dao.templates_dao import (
+    dao_get_template_by_id_and_service_id,
+    get_precompiled_letter_template,
+)
 from app.dao.users_dao import get_user_by_id
 from app.letters.utils import (
     get_billable_units_for_letter_page_count,
@@ -36,6 +22,25 @@ from app.letters.utils import (
     get_page_count,
     move_uploaded_pdf_to_letters_bucket,
 )
+from app.models import (
+    EMAIL_TYPE,
+    KEY_TYPE_NORMAL,
+    LETTER_TYPE,
+    NOTIFICATION_DELIVERED,
+    PRIORITY,
+    SMS_TYPE,
+)
+from app.notifications.process_notifications import (
+    persist_notification,
+    send_notification_to_queue,
+)
+from app.notifications.validators import (
+    check_service_has_permission,
+    check_service_over_daily_message_limit,
+    validate_address,
+    validate_and_format_recipient,
+    validate_template,
+)
 from app.v2.errors import BadRequestError
 
 

app/service/sender.py

@@ -1,10 +1,16 @@
 from flask import current_app
 
 from app.config import QueueNames
-from app.dao.services_dao import dao_fetch_service_by_id, dao_fetch_active_users_for_service
+from app.dao.services_dao import (
+    dao_fetch_active_users_for_service,
+    dao_fetch_service_by_id,
+)
 from app.dao.templates_dao import dao_get_template_by_id
 from app.models import EMAIL_TYPE, KEY_TYPE_NORMAL
-from app.notifications.process_notifications import persist_notification, send_notification_to_queue
+from app.notifications.process_notifications import (
+    persist_notification,
+    send_notification_to_queue,
+)
 
 
 def send_notification_to_service_users(service_id, template_id, personalisation=None, include_user_fields=None):

app/service/service_callback_api_schema.py

@@ -1,4 +1,4 @@
-from app.schema_validation.definitions import uuid, https_url
+from app.schema_validation.definitions import https_url, uuid
 
 create_service_callback_api_schema = {
     "$schema": "http://json-schema.org/draft-04/schema#",

app/service/statistics.py

@@ -3,8 +3,8 @@ from datetime import datetime
 
 from notifications_utils.timezones import convert_utc_to_bst
 
-from app.models import NOTIFICATION_STATUS_TYPES, NOTIFICATION_TYPES
 from app.dao.date_util import get_months_for_financial_year
+from app.models import NOTIFICATION_STATUS_TYPES, NOTIFICATION_TYPES
 
 
 def format_statistics(statistics):

app/service/utils.py

@@ -2,12 +2,15 @@ import itertools
 
 from notifications_utils.recipients import allowed_to_send_to
 
-from app.models import (
-    ServiceGuestList,
-    MOBILE_TYPE, EMAIL_TYPE,
-    KEY_TYPE_TEST, KEY_TYPE_TEAM, KEY_TYPE_NORMAL)
-
 from app.dao.services_dao import dao_fetch_service_by_id
+from app.models import (
+    EMAIL_TYPE,
+    KEY_TYPE_NORMAL,
+    KEY_TYPE_TEAM,
+    KEY_TYPE_TEST,
+    MOBILE_TYPE,
+    ServiceGuestList,
+)
 
 
 def get_recipients_from_request(request_json, key, type):

app/status/healthcheck.py

@@ -1,12 +1,8 @@
-from flask import (
-    jsonify,
-    Blueprint,
-    request
-)
+from flask import Blueprint, jsonify, request
 
 from app import db, version
-from app.dao.services_dao import dao_count_live_services
 from app.dao.organisation_dao import dao_count_organisations_with_live_services
+from app.dao.services_dao import dao_count_live_services
 
 status = Blueprint('status', __name__)
 

app/template/rest.py

@@ -2,42 +2,44 @@ import base64
 from io import BytesIO
 
 import botocore
-from PyPDF2.utils import PdfReadError
-from flask import (
-    Blueprint,
-    current_app,
-    jsonify,
-    request)
+from flask import Blueprint, current_app, jsonify, request
 from notifications_utils import SMS_CHAR_COUNT_LIMIT
 from notifications_utils.pdf import extract_page_from_pdf
 from notifications_utils.template import SMSMessageTemplate
+from PyPDF2.utils import PdfReadError
 from requests import post as requests_post
 from sqlalchemy.orm.exc import NoResultFound
 
 from app.dao.notifications_dao import get_notification_by_id
 from app.dao.services_dao import dao_fetch_service_by_id
-from app.dao.template_folder_dao import dao_get_template_folder_by_id_and_service_id
+from app.dao.template_folder_dao import (
+    dao_get_template_folder_by_id_and_service_id,
+)
 from app.dao.templates_dao import (
-    dao_update_template,
     dao_create_template,
-    dao_redact_template,
-    dao_get_template_by_id_and_service_id,
     dao_get_all_templates_for_service,
-    dao_get_template_versions,
-    dao_update_template_reply_to,
     dao_get_template_by_id,
+    dao_get_template_by_id_and_service_id,
+    dao_get_template_versions,
+    dao_redact_template,
+    dao_update_template,
+    dao_update_template_reply_to,
     get_precompiled_letter_template,
 )
-from app.errors import (
-    register_errors,
-    InvalidRequest
-)
+from app.errors import InvalidRequest, register_errors
 from app.letters.utils import get_letter_pdf_and_metadata
-from app.models import SMS_TYPE, Template, SECOND_CLASS, LETTER_TYPE
-from app.notifications.validators import service_has_permission, check_reply_to
+from app.models import LETTER_TYPE, SECOND_CLASS, SMS_TYPE, Template
+from app.notifications.validators import check_reply_to, service_has_permission
 from app.schema_validation import validate
-from app.schemas import (template_schema, template_schema_no_detail, template_history_schema)
-from app.template.template_schemas import post_create_template_schema, post_update_template_schema
+from app.schemas import (
+    template_history_schema,
+    template_schema,
+    template_schema_no_detail,
+)
+from app.template.template_schemas import (
+    post_create_template_schema,
+    post_update_template_schema,
+)
 from app.utils import get_public_notify_type_text
 
 template_blueprint = Blueprint('template', __name__, url_prefix='/service/<uuid:service_id>/template')

app/template/template_schemas.py

@@ -1,7 +1,4 @@
-from app.models import (
-    TEMPLATE_PROCESS_TYPE,
-    TEMPLATE_TYPES,
-)
+from app.models import TEMPLATE_PROCESS_TYPE, TEMPLATE_TYPES
 from app.schema_validation.definitions import nullable_uuid, uuid
 
 post_create_template_schema = {

app/template_folder/rest.py

@@ -1,26 +1,28 @@
-from flask import Blueprint, jsonify, request, current_app
+from flask import Blueprint, current_app, jsonify, request
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm.exc import NoResultFound
 
 from app.dao.dao_utils import transactional
-from app.dao.templates_dao import dao_get_template_by_id_and_service_id
-from app.dao.template_folder_dao import (
-    dao_create_template_folder,
-    dao_get_template_folder_by_id_and_service_id,
-    dao_update_template_folder,
-    dao_delete_template_folder
+from app.dao.service_user_dao import (
+    dao_get_active_service_users,
+    dao_get_service_user,
 )
 from app.dao.services_dao import dao_fetch_service_by_id
-from app.dao.service_user_dao import dao_get_active_service_users
-from app.dao.service_user_dao import dao_get_service_user
+from app.dao.template_folder_dao import (
+    dao_create_template_folder,
+    dao_delete_template_folder,
+    dao_get_template_folder_by_id_and_service_id,
+    dao_update_template_folder,
+)
+from app.dao.templates_dao import dao_get_template_by_id_and_service_id
 from app.errors import InvalidRequest, register_errors
 from app.models import TemplateFolder
+from app.schema_validation import validate
 from app.template_folder.template_folder_schema import (
     post_create_template_folder_schema,
-    post_update_template_folder_schema,
     post_move_template_folder_schema,
+    post_update_template_folder_schema,
 )
-from app.schema_validation import validate
 
 template_folder_blueprint = Blueprint(
     'template_folder',