refactor: format with black and isort

Author: symwell

appmap/_implementation/detect_enabled.py

@@ -5,14 +5,15 @@
 import importlib
 import logging
 import os
-
 from textwrap import dedent
 
 logger = logging.getLogger(__name__)
 
+
 class UnrecognizedRecordingMethodException(Exception):
     pass
 
+
 RECORDING_METHODS = ["pytest", "unittest", "remote", "requests"]
 
 # Detects whether AppMap recording should be enabled. This test can be
@@ -59,12 +60,10 @@ def should_enable(cls, recording_method):
             message, enabled = cls.detect_should_enable(recording_method)
             cls._detected_for_method[recording_method] = enabled
             if enabled:
-                logger.warning(
-                    dedent(f"AppMap recording is enabled because {message}")
-                )
+                logger.warning(dedent(f"AppMap recording is enabled because {message}"))
             return enabled
 
-    @classmethod  
+    @classmethod
     def detect_should_enable(cls, recording_method):
         if not recording_method:
             return ["no recording method is set", False]
@@ -73,21 +72,21 @@ def detect_should_enable(cls, recording_method):
             return ["invalid recording method", False]
 
         # explicitly disabled or enabled
-        if 'APPMAP' in os.environ:
-            if os.environ['APPMAP'] == 'false':
+        if "APPMAP" in os.environ:
+            if os.environ["APPMAP"] == "false":
                 return ["APPMAP=false", False]
-            elif os.environ['APPMAP'] == 'true':
+            elif os.environ["APPMAP"] == "true":
                 return ["APPMAP=true", True]
 
         # recording method explicitly disabled or enabled
         if recording_method:
             for one_recording_method in RECORDING_METHODS:
                 if one_recording_method == recording_method.lower():
-                    env_var = '_'.join([ 'APPMAP', 'RECORD', recording_method.upper() ])
+                    env_var = "_".join(["APPMAP", "RECORD", recording_method.upper()])
                     if env_var in os.environ:
-                        if os.environ[env_var] == 'false':
+                        if os.environ[env_var] == "false":
                             return [f"{env_var}=false", False]
-                        elif os.environ[env_var] == 'true':
+                        elif os.environ[env_var] == "true":
                             return [f"{env_var}=true", True]
 
         # it's flask
@@ -104,35 +103,50 @@ def detect_should_enable(cls, recording_method):
 
     @classmethod
     def is_flask_and_should_enable(cls):
-        if 'FLASK_DEBUG' in os.environ and os.environ['FLASK_DEBUG'] == '1':
+        if "FLASK_DEBUG" in os.environ and os.environ["FLASK_DEBUG"] == "1":
             return [f"FLASK_DEBUG={os.environ['FLASK_DEBUG']}", True]
 
-        if 'FLASK_ENV' in os.environ and os.environ['FLASK_ENV'] == 'development':
+        if "FLASK_ENV" in os.environ and os.environ["FLASK_ENV"] == "development":
             return [f"FLASK_ENV={os.environ['FLASK_ENV']}", True]
 
         return ["it is not Flask", False]
 
     @classmethod
     def is_django_and_should_enable(cls):
-        if 'DJANGO_SETTINGS_MODULE' in os.environ and os.environ['DJANGO_SETTINGS_MODULE'] != '':
+        if (
+            "DJANGO_SETTINGS_MODULE" in os.environ
+            and os.environ["DJANGO_SETTINGS_MODULE"] != ""
+        ):
             try:
-                settings = importlib.import_module(os.environ['DJANGO_SETTINGS_MODULE'])
+                settings = importlib.import_module(os.environ["DJANGO_SETTINGS_MODULE"])
             except Exception as exn:
                 settings = None
-                return ["couldn't load DJANGO_SETTINGS_MODULE={os.environ['DJANGO_SETTINGS_MODULE']}", False]
+                return [
+                    "couldn't load DJANGO_SETTINGS_MODULE={os.environ['DJANGO_SETTINGS_MODULE']}",
+                    False,
+                ]
 
             if settings:
                 try:
                     if settings.DEBUG == True:
-                        return [f"{os.environ['DJANGO_SETTINGS_MODULE']}.DEBUG={settings.DEBUG}", True]
+                        return [
+                            f"{os.environ['DJANGO_SETTINGS_MODULE']}.DEBUG={settings.DEBUG}",
+                            True,
+                        ]
                 except Exception as exn:
                     # it wasn't set. it's ok
                     pass
 
             if settings:
                 try:
-                    if settings.APPMAP == True or str(settings.APPMAP).upper() == 'true'.upper():
-                        return [f"{os.environ['DJANGO_SETTINGS_MODULE']}.APPMAP={settings.APPMAP}", True]
+                    if (
+                        settings.APPMAP == True
+                        or str(settings.APPMAP).upper() == "true".upper()
+                    ):
+                        return [
+                            f"{os.environ['DJANGO_SETTINGS_MODULE']}.APPMAP={settings.APPMAP}",
+                            True,
+                        ]
                 except Exception as exn:
                     # it wasn't set. it's ok
                     pass

appmap/_implementation/testing_framework.py

@@ -1,7 +1,7 @@
 """Shared infrastructure for testing framework integration."""
 
-import re
 import os
+import re
 from contextlib import contextmanager
 
 import inflection
@@ -146,11 +146,13 @@ def collect_result_metadata(metadata):
         metadata["exception"] = {"class": exn.__class__.__name__, "message": str(exn)}
         raise
 
+
 def file_write(filename, contents):
     f = open(filename, "w")
     f.write(contents)
     f.close()
 
+
 def file_delete(filename):
     try:
         os.remove(filename)

appmap/_implementation/web_framework.py

@@ -130,13 +130,10 @@ def create_appmap_file(
 
 
 class AppmapMiddleware:
-
     def __init__(self):
         self.record_url = "/_appmap/record"
 
-    def before_request_hook(
-        self, request, request_path, recording_is_running
-    ):
+    def before_request_hook(self, request, request_path, recording_is_running):
         if request_path == self.record_url:
             return None, None, None
 

appmap/test/test_detect_enabled.py

@@ -2,11 +2,14 @@
 Test detecting if AppMap is enabled
 """
 import os
-import pytest
 import unittest
 from unittest.mock import patch
-from appmap._implementation.detect_enabled import DetectEnabled, RECORDING_METHODS
-from appmap._implementation.testing_framework import file_write, file_delete
+
+import pytest
+
+from appmap._implementation.detect_enabled import RECORDING_METHODS, DetectEnabled
+from appmap._implementation.testing_framework import file_delete, file_write
+
 
 class TestDetectEnabled:
     @staticmethod
@@ -46,25 +49,28 @@ def test_some__appmap_enabled(self):
             assert DetectEnabled.should_enable(recording_method) == True
 
     recording_methods_as_true = {
-        '_'.join([ "APPMAP", "RECORD", recording_method.upper()]): "true"
+        "_".join(["APPMAP", "RECORD", recording_method.upper()]): "true"
         for recording_method in RECORDING_METHODS
     }
+
     @patch.dict(os.environ, recording_methods_as_true)
     def test_some__recording_method_enabled(self):
         for recording_method in RECORDING_METHODS:
             DetectEnabled.initialize()
             assert DetectEnabled.should_enable(recording_method) == True
 
     recording_methods_as_false = {
-        '_'.join([ "APPMAP", "RECORD", recording_method.upper()]): "false"
+        "_".join(["APPMAP", "RECORD", recording_method.upper()]): "false"
         for recording_method in RECORDING_METHODS
     }
+
     @patch.dict(os.environ, recording_methods_as_false)
     def test_some__recording_method_disabled(self):
         for recording_method in RECORDING_METHODS:
             DetectEnabled.initialize()
             assert DetectEnabled.should_enable(recording_method) == False
 
+
 class TestDetectEnabledFlask:
     @staticmethod
     def setup_method():
@@ -99,8 +105,8 @@ def test__flask_env_development(self):
         DetectEnabled.initialize()
         assert DetectEnabled.should_enable("requests") == True
 
-class TestDetectEnabledDjango:
 
+class TestDetectEnabledDjango:
     @staticmethod
     def setup_method():
         DetectEnabled.clear_cache()
@@ -109,8 +115,17 @@ def test__none(self):
         DetectEnabled.initialize()
         assert DetectEnabled.should_enable(None) == False
 
-    def driver(self, data_dir, monkeypatch, django_settings_module, basename_settings, extra_settings_content, expected):
-        settings_content = """
+    def driver(
+        self,
+        data_dir,
+        monkeypatch,
+        django_settings_module,
+        basename_settings,
+        extra_settings_content,
+        expected,
+    ):
+        settings_content = (
+            """
 # If the SECRET_KEY isn't defined we get the misleading error message
 # CommandError: You must set settings.ALLOWED_HOSTS if DEBUG is False.
 SECRET_KEY = "3*+d^_kjnr2gz)4q2m(&&^%$p4fj5dk3%lz4pl3g4m-%6!gf&)"
@@ -121,8 +136,11 @@ def driver(self, data_dir, monkeypatch, django_settings_module, basename_setting
 
 MIDDLEWARE = ["appmap.django.Middleware"]
 
-""" + extra_settings_content + """
 """
+            + extra_settings_content
+            + """
+"""
+        )
         monkeypatch.syspath_prepend(data_dir / "django")
         monkeypatch.setenv("DJANGO_SETTINGS_MODULE", django_settings_module)
         filename = data_dir / "django" / "app" / basename_settings
@@ -141,7 +159,7 @@ def test__debug_false(self, data_dir, monkeypatch):
             "app.settings_debug_false",
             "settings_debug_false.py",
             "DEBUG = False",
-            False
+            False,
         )
 
     def test__debug_true(self, data_dir, monkeypatch):
@@ -151,7 +169,7 @@ def test__debug_true(self, data_dir, monkeypatch):
             "app.settings_debug_true",
             "settings_debug_true.py",
             "DEBUG = True",
-            True
+            True,
         )
 
     # note this is APPMAP = False in the settings, not the env
@@ -162,7 +180,7 @@ def test__appmap_false(self, data_dir, monkeypatch):
             "app.settings_appmap_false",
             "settings_appmap_false.py",
             "APPMAP = False",
-            False
+            False,
         )
 
     def test__appmap_true(self, data_dir, monkeypatch):
@@ -172,5 +190,5 @@ def test__appmap_true(self, data_dir, monkeypatch):
             "app.settings_appmap_true",
             "settings_appmap_true.py",
             "APPMAP = True",
-            True
+            True,
         )

appmap/test/test_django.py

@@ -193,7 +193,6 @@ def test_middleware_reset(pytester, monkeypatch):
 
 
 class TestRecordRequestsDjango(TestRecordRequests):
-
     @staticmethod
     def server_start_thread(env_vars_str):
         exec_cmd(
@@ -202,14 +201,18 @@ def server_start_thread(env_vars_str):
 export PYTHONPATH=`pwd`
 
 cd appmap/test/data/django/
-""" + env_vars_str + """ python manage.py runserver 127.0.0.1:"""
+"""
+            + env_vars_str
+            + """ python manage.py runserver 127.0.0.1:"""
             + str(TestRecordRequests.server_port)
         )
 
     @staticmethod
     def server_start(env_vars_str):
         # start as background thread so running the tests can continue
-        thread = Thread(target=TestRecordRequestsDjango.server_start_thread, args=(env_vars_str,))
+        thread = Thread(
+            target=TestRecordRequestsDjango.server_start_thread, args=(env_vars_str,)
+        )
         thread.start()
         wait_until_port_is("127.0.0.1", TestRecordRequests.server_port, "open")
 
@@ -220,30 +223,42 @@ def server_stop():
         )
         wait_until_port_is("127.0.0.1", TestRecordRequests.server_port, "closed")
 
-    @pytest.mark.skipif(True, reason="don't pass until _EventIds stops producing duplicate ids")
+    @pytest.mark.skipif(
+        True, reason="don't pass until _EventIds stops producing duplicate ids"
+    )
     def test_record_request_appmap_enabled_requests_enabled_no_remote(client, events):
         TestRecordRequestsDjango.server_stop()  # ensure it's not running
         TestRecordRequestsDjango.server_start("APPMAP=true APPMAP_RECORD_REQUESTS=true")
         TestRecordRequests.record_request(client, events, False)
         TestRecordRequestsDjango.server_stop()
 
-    @pytest.mark.skipif(True, reason="don't pass until _EventIds stops producing duplicate ids")
+    @pytest.mark.skipif(
+        True, reason="don't pass until _EventIds stops producing duplicate ids"
+    )
     def test_record_request_appmap_enabled_requests_enabled_and_remote(client, events):
         TestRecordRequestsDjango.server_stop()  # ensure it's not running
         TestRecordRequestsDjango.server_start("APPMAP=true APPMAP_RECORD_REQUESTS=true")
         TestRecordRequests.record_request(client, events, True)
         TestRecordRequestsDjango.server_stop()
 
     # not enabled means APPMAP isn't set.  This isn't the same as APPMAP=false.
-    @pytest.mark.skipif(True, reason="don't pass until _EventIds stops producing duplicate ids")
-    def test_record_request_appmap_not_enabled_requests_enabled_no_remote(client, events):
+    @pytest.mark.skipif(
+        True, reason="don't pass until _EventIds stops producing duplicate ids"
+    )
+    def test_record_request_appmap_not_enabled_requests_enabled_no_remote(
+        client, events
+    ):
         TestRecordRequestsDjango.server_stop()  # ensure it's not running
         TestRecordRequestsDjango.server_start("APPMAP_RECORD_REQUESTS=true")
         TestRecordRequests.record_request(client, events, False)
         TestRecordRequestsDjango.server_stop()
 
-    @pytest.mark.skipif(True, reason="don't pass until _EventIds stops producing duplicate ids")
-    def test_record_request_appmap_not_enabled_requests_enabled_and_remote(client, events):
+    @pytest.mark.skipif(
+        True, reason="don't pass until _EventIds stops producing duplicate ids"
+    )
+    def test_record_request_appmap_not_enabled_requests_enabled_and_remote(
+        client, events
+    ):
         TestRecordRequestsDjango.server_stop()  # ensure it's not running
         TestRecordRequestsDjango.server_start("APPMAP_RECORD_REQUESTS=true")
         TestRecordRequests.record_request(client, events, True)