Blacken files

Author: Ben Dickinson

pattern_library/__init__.py

@@ -6,60 +6,61 @@
     default_app_config = "pattern_library.apps.PatternLibraryAppConfig"
 
 __all__ = [
-    'DEFAULT_SETTINGS',
-    'get_setting',
-    'get_pattern_template_suffix',
-    'get_pattern_base_template_name',
-    'get_base_template_names',
-    'get_sections',
-    'get_pattern_context_var_name',
-    'register_context_modifier',
+    "DEFAULT_SETTINGS",
+    "get_setting",
+    "get_pattern_template_suffix",
+    "get_pattern_base_template_name",
+    "get_base_template_names",
+    "get_sections",
+    "get_pattern_context_var_name",
+    "register_context_modifier",
 ]
 
 DEFAULT_SETTINGS = {
     # PATTERN_BASE_TEMPLATE_NAME is the template that fragments will be wrapped with.
     # It should include any required CSS and JS and output
     # `pattern_library_rendered_pattern` from context.
-    'PATTERN_BASE_TEMPLATE_NAME': 'patterns/base.html',
+    "PATTERN_BASE_TEMPLATE_NAME": "patterns/base.html",
     # Any template in BASE_TEMPLATE_NAMES or any template that extends a template in
     # BASE_TEMPLATE_NAMES is a "page" and will be rendered as-is without being wrapped.
-    'BASE_TEMPLATE_NAMES': ['patterns/base_page.html'],
-    'TEMPLATE_SUFFIX': '.html',
+    "BASE_TEMPLATE_NAMES": ["patterns/base_page.html"],
+    "TEMPLATE_SUFFIX": ".html",
     # SECTIONS controls the groups of templates that appear in the navigation. The keys
     # are the group titles and the value are lists of template name prefixes that will
     # be searched to populate the groups.
-    'SECTIONS': (
-        ('atoms', ['patterns/atoms']),
-        ('molecules', ['patterns/molecules']),
-        ('organisms', ['patterns/organisms']),
-        ('templates', ['patterns/templates']),
-        ('pages', ['patterns/pages']),
+    "SECTIONS": (
+        ("atoms", ["patterns/atoms"]),
+        ("molecules", ["patterns/molecules"]),
+        ("organisms", ["patterns/organisms"]),
+        ("templates", ["patterns/templates"]),
+        ("pages", ["patterns/pages"]),
     ),
 }
 
 
 def get_setting(attr):
     from django.conf import settings
+
     library_settings = DEFAULT_SETTINGS.copy()
-    library_settings.update(getattr(settings, 'PATTERN_LIBRARY', {}))
+    library_settings.update(getattr(settings, "PATTERN_LIBRARY", {}))
     return library_settings.get(attr)
 
 
 def get_pattern_template_suffix():
-    return get_setting('TEMPLATE_SUFFIX')
+    return get_setting("TEMPLATE_SUFFIX")
 
 
 def get_pattern_base_template_name():
-    return get_setting('PATTERN_BASE_TEMPLATE_NAME')
+    return get_setting("PATTERN_BASE_TEMPLATE_NAME")
 
 
 def get_base_template_names():
-    return get_setting('BASE_TEMPLATE_NAMES')
+    return get_setting("BASE_TEMPLATE_NAMES")
 
 
 def get_sections():
-    return get_setting('SECTIONS')
+    return get_setting("SECTIONS")
 
 
 def get_pattern_context_var_name():
-    return 'is_pattern_library'
+    return "is_pattern_library"

pattern_library/apps.py

@@ -2,5 +2,5 @@
 
 
 class PatternLibraryAppConfig(AppConfig):
-    name = 'pattern_library'
-    default_auto_field = 'django.db.models.AutoField'
+    name = "pattern_library"
+    default_auto_field = "django.db.models.AutoField"

pattern_library/cm_utils.py

@@ -1,4 +1,3 @@
-
 import inspect
 from importlib import import_module
 from typing import Callable
@@ -23,7 +22,7 @@ def get_app_submodules(submodule_name):
     """
     for name, module in get_app_modules():
         if module_has_submodule(module, submodule_name):
-            yield name, import_module('%s.%s' % (name, submodule_name))
+            yield name, import_module("%s.%s" % (name, submodule_name))
 
 
 def accepts_kwarg(func: Callable, kwarg: str) -> bool:

pattern_library/context_modifiers.py

@@ -9,10 +9,7 @@
 GENERIC_CM_KEY = "__generic__"
 ORDER_ATTR_NAME = "__cm_order"
 
-__all__ = [
-    "ContextModifierRegistry",
-    "register_context_modifier"
-]
+__all__ = ["ContextModifierRegistry", "register_context_modifier"]
 
 
 class ContextModifierRegistry(defaultdict):
@@ -22,7 +19,7 @@ def __init__(self):
 
     def search_for_modifiers(self) -> None:
         if not self.searched_for_modifiers:
-            list(get_app_submodules('pattern_contexts'))
+            list(get_app_submodules("pattern_contexts"))
             self.searched_for_modifiers = True
 
     def register(self, func: Callable, template: str = None, order: int = 0) -> None:

pattern_library/exceptions.py

@@ -1,5 +1,3 @@
-
-
 class PatternLibraryException(Exception):
     pass
 

pattern_library/loader_tags.py

@@ -4,9 +4,7 @@
 from django.template.loader_tags import IncludeNode as DjangoIncludeNode
 from django.template.loader_tags import construct_relative_path
 
-from pattern_library.utils import (
-    get_pattern_context, is_pattern_library_context
-)
+from pattern_library.utils import get_pattern_context, is_pattern_library_context
 
 register = Library()
 
@@ -15,6 +13,7 @@ class ExtendsNode(DjangoExtendsNode):
     """
     A copy of Django's ExtendsNode that injects context from a file.
     """
+
     def render(self, context):
         if is_pattern_library_context(context):
             parent_name = self.parent_name.resolve(context)
@@ -58,11 +57,14 @@ class IncludeNode(DjangoIncludeNode):
     """
     A copy of Django's IncludeNode that injects context from a file.
     """
+
     def render(self, context):
         if is_pattern_library_context(context):
             template = self.template.resolve(context)
             pattern_context = get_pattern_context(template)
-            extra_context = {name: var.resolve(context) for name, var in self.extra_context.items()}
+            extra_context = {
+                name: var.resolve(context) for name, var in self.extra_context.items()
+            }
 
             if self.isolated_context:
                 context = context.new()
@@ -88,7 +90,7 @@ def render(self, context):
         return super().render(context)
 
 
-@register.tag('extends')
+@register.tag("extends")
 def do_extends(parser, token):
     """
     A copy of Django's built-in {% extends ... %} tag that uses our custom
@@ -101,11 +103,13 @@ def do_extends(parser, token):
     parent_name = parser.compile_filter(bits[1])
     nodelist = parser.parse()
     if nodelist.get_nodes_by_type(ExtendsNode):
-        raise TemplateSyntaxError("'%s' cannot appear more than once in the same template" % bits[0])
+        raise TemplateSyntaxError(
+            "'%s' cannot appear more than once in the same template" % bits[0]
+        )
     return ExtendsNode(nodelist, parent_name)
 
 
-@register.tag('include')
+@register.tag("include")
 def do_include(parser, token):
     """
     A copy of Django's built-in {% include ... %} tag that uses our custom
@@ -122,21 +126,27 @@ def do_include(parser, token):
     while remaining_bits:
         option = remaining_bits.pop(0)
         if option in options:
-            raise TemplateSyntaxError('The %r option was specified more '
-                                      'than once.' % option)
-        if option == 'with':
+            raise TemplateSyntaxError(
+                "The %r option was specified more " "than once." % option
+            )
+        if option == "with":
             value = token_kwargs(remaining_bits, parser, support_legacy=False)
             if not value:
-                raise TemplateSyntaxError('"with" in %r tag needs at least '
-                                          'one keyword argument.' % bits[0])
-        elif option == 'only':
+                raise TemplateSyntaxError(
+                    '"with" in %r tag needs at least ' "one keyword argument." % bits[0]
+                )
+        elif option == "only":
             value = True
         else:
-            raise TemplateSyntaxError('Unknown argument for %r tag: %r.' %
-                                      (bits[0], option))
+            raise TemplateSyntaxError(
+                "Unknown argument for %r tag: %r." % (bits[0], option)
+            )
         options[option] = value
-    isolated_context = options.get('only', False)
-    namemap = options.get('with', {})
+    isolated_context = options.get("only", False)
+    namemap = options.get("with", {})
     bits[1] = construct_relative_path(parser.origin.template_name, bits[1])
-    return IncludeNode(parser.compile_filter(bits[1]), extra_context=namemap,
-                       isolated_context=isolated_context)
+    return IncludeNode(
+        parser.compile_filter(bits[1]),
+        extra_context=namemap,
+        isolated_context=isolated_context,
+    )

pattern_library/management/commands/render_patterns.py

@@ -4,12 +4,12 @@
 from django.template.loader import render_to_string
 from django.test.client import RequestFactory
 
-from pattern_library import (
-    get_base_template_names, get_pattern_base_template_name
-)
+from pattern_library import get_base_template_names, get_pattern_base_template_name
 from pattern_library.utils import (
-    get_pattern_context, get_pattern_templates, get_template_ancestors,
-    render_pattern
+    get_pattern_context,
+    get_pattern_templates,
+    get_template_ancestors,
+    render_pattern,
 )
 
 
@@ -19,44 +19,46 @@ class Command(BaseCommand):
     def add_arguments(self, parser):
         super().add_arguments(parser)
         parser.add_argument(
-            '--output',
-            '-o',
-            action='store',
-            dest='output_dir',
-            default='dpl-rendered-patterns',
-            help='Directory where to render your patterns',
+            "--output",
+            "-o",
+            action="store",
+            dest="output_dir",
+            default="dpl-rendered-patterns",
+            help="Directory where to render your patterns",
             type=str,
         )
         parser.add_argument(
-            '--dry-run',
-            action='store_true',
+            "--dry-run",
+            action="store_true",
             help="Render the patterns without writing them to disk.",
         )
         parser.add_argument(
-            '--wrap-fragments',
-            action='store_true',
+            "--wrap-fragments",
+            action="store_true",
             help="Render fragment patterns wrapped in the base template.",
         )
 
     def handle(self, **options):
-        self.verbosity = options['verbosity']
-        self.dry_run = options['dry_run']
-        self.wrap_fragments = options['wrap_fragments']
-        self.output_dir = options['output_dir']
+        self.verbosity = options["verbosity"]
+        self.dry_run = options["dry_run"]
+        self.wrap_fragments = options["wrap_fragments"]
+        self.output_dir = options["output_dir"]
 
         templates = get_pattern_templates()
 
         factory = RequestFactory()
-        request = factory.get('/')
+        request = factory.get("/")
 
         if self.verbosity >= 2:
             if self.dry_run:
-                self.stderr.write(f'Target directory: {self.output_dir}. Dry run, not writing files to disk')
+                self.stderr.write(
+                    f"Target directory: {self.output_dir}. Dry run, not writing files to disk"
+                )
             else:
-                self.stderr.write(f'Target directory: {self.output_dir}')
+                self.stderr.write(f"Target directory: {self.output_dir}")
 
             if self.wrap_fragments:
-                self.stderr.write('Writing fragment patterns wrapped in base template')
+                self.stderr.write("Writing fragment patterns wrapped in base template")
 
         # Resolve the output dir according to the directory the command is run from.
         parent_dir = Path.cwd().joinpath(self.output_dir)
@@ -67,27 +69,31 @@ def handle(self, **options):
         self.render_group(request, parent_dir, templates)
 
     def render_group(self, request, parent_dir: Path, pattern_templates):
-        for template in pattern_templates['templates_stored']:
+        for template in pattern_templates["templates_stored"]:
             if self.verbosity >= 2:
-                self.stderr.write(f'Pattern: {template.pattern_filename}')
+                self.stderr.write(f"Pattern: {template.pattern_filename}")
             if self.verbosity >= 1:
                 self.stderr.write(template.origin.template_name)
 
             render_path = parent_dir.joinpath(template.pattern_filename)
-            rendered_pattern = self.render_pattern(request, template.origin.template_name)
+            rendered_pattern = self.render_pattern(
+                request, template.origin.template_name
+            )
 
             if self.dry_run:
                 if self.verbosity >= 2:
                     self.stdout.write(rendered_pattern)
             else:
                 render_path.write_text(rendered_pattern)
 
-        if not pattern_templates['template_groups']:
+        if not pattern_templates["template_groups"]:
             return
 
-        for pattern_type_group, pattern_templates in pattern_templates['template_groups'].items():
+        for pattern_type_group, pattern_templates in pattern_templates[
+            "template_groups"
+        ].items():
             if self.verbosity >= 2:
-                self.stderr.write(f'Group: {pattern_type_group}')
+                self.stderr.write(f"Group: {pattern_type_group}")
             group_parent = parent_dir.joinpath(pattern_type_group)
             if not self.dry_run:
                 group_parent.mkdir(exist_ok=True)
@@ -104,12 +110,14 @@ def render_pattern(self, request, pattern_template_name):
             pattern_template_name,
             context=get_pattern_context(pattern_template_name),
         )
-        pattern_is_fragment = set(pattern_template_ancestors).isdisjoint(set(get_base_template_names()))
+        pattern_is_fragment = set(pattern_template_ancestors).isdisjoint(
+            set(get_base_template_names())
+        )
 
         if pattern_is_fragment:
             base_template = get_pattern_base_template_name()
             context = get_pattern_context(base_template)
-            context['pattern_library_rendered_pattern'] = rendered_pattern
+            context["pattern_library_rendered_pattern"] = rendered_pattern
             return render_to_string(base_template, request=request, context=context)
         else:
             return rendered_pattern