" -> '

diegojromerolopez · diegojromerolopez · commit d6e32a35b6fc · 2021-08-22T18:07:22.000+02:00
diff --git a/async_include/checksum.py b/async_include/checksum.py
@@ -8,7 +8,7 @@
 
 
 def make(string):
-    key = "{0}-{1}".format(string, settings.SECRET_KEY)
+    key = '{0}-{1}'.format(string, settings.SECRET_KEY)
 
     try:
         return hashlib.md5(key).hexdigest()
diff --git a/async_include/crypto.py b/async_include/crypto.py
@@ -6,16 +6,16 @@
 
 
 def encrypt(key, data):
-    cipher = AES.new(key.encode("utf-8"), AES.MODE_EAX)
-    encrypted_data, tag = cipher.encrypt_and_digest(data.encode("utf-8"))
+    cipher = AES.new(key.encode('utf-8'), AES.MODE_EAX)
+    encrypted_data, tag = cipher.encrypt_and_digest(data.encode('utf-8'))
     return cipher.nonce, encrypted_data, tag
 
 
 def decrypt(key, nonce, encrypted_data, tag):
     cipher = AES.new(
-        key.encode("utf-8"), AES.MODE_EAX, nonce.encode("latin-1")
+        key.encode('utf-8'), AES.MODE_EAX, nonce.encode('latin-1')
     )
     data = cipher.decrypt_and_verify(
-        encrypted_data.encode("latin-1"), tag.encode("latin-1")
+        encrypted_data.encode('latin-1'), tag.encode('latin-1')
     )
-    return data.decode("utf-8")
+    return data.decode('utf-8')
diff --git a/async_include/templatetags/async_include.py b/async_include/templatetags/async_include.py
@@ -26,7 +26,7 @@ def get_unique_template_id():
     Get an unique id for a template as a string.
     :return: an unique id for a template.
     """
-    return uuid.uuid4().urn[9:].replace("-", "")
+    return uuid.uuid4().urn[9:].replace('-', '')
 
 
 def slugify_template_path(template_path):
@@ -37,7 +37,7 @@ def slugify_template_path(template_path):
     :param template_path: string with the template path.
     :return: slug of the template path.
     """
-    return slugify(template_path.replace("/", "_").replace("-", "_"))
+    return slugify(template_path.replace('/', '_').replace('-', '_'))
 
 
 # Async include template tag.
@@ -52,44 +52,44 @@ def async_include(context, template_path, *args, **kwargs):
     slugified_template_path = slugify_template_path(template_path)
 
     # Unique block id (uniqueness based on UUID)
-    block_id = "{0}__{1}".format(
+    block_id = '{0}__{1}'.format(
         slugified_template_path, get_unique_template_id()
     )
 
     # Give the possibility to customize the HTML tag
-    html__tag = kwargs.pop("html__tag", "div")
+    html__tag = kwargs.pop('html__tag', 'div')
 
     # HTML tag class
-    html__tag__class = kwargs.pop("html__tag__class", slugified_template_path)
+    html__tag__class = kwargs.pop('html__tag__class', slugified_template_path)
 
     # Shall we show a spinner?
-    spinner__visible = kwargs.pop("spinner__visible", True)
+    spinner__visible = kwargs.pop('spinner__visible', True)
 
     # Spinner template path
     spinner__template_path = kwargs.pop(
-        "spinner__template_path", "async_include/spinner.html"
+        'spinner__template_path', 'async_include/spinner.html'
     )
 
     # Recurrent requests
-    request__frequency = kwargs.pop("request__frequency", "once")
+    request__frequency = kwargs.pop('request__frequency', 'once')
 
     replacements = {
-        "template_path": template_path,
-        "block_id": block_id,
-        "html__tag": html__tag,
-        "html__tag__class": html__tag__class,
-        "spinner__visible": spinner__visible,
-        "spinner__template_path": spinner__template_path,
-        "request__frequency": request__frequency,
-        "context": {}
+        'template_path': template_path,
+        'block_id': block_id,
+        'html__tag': html__tag,
+        'html__tag__class': html__tag__class,
+        'spinner__visible': spinner__visible,
+        'spinner__template_path': spinner__template_path,
+        'request__frequency': request__frequency,
+        'context': {}
     }
 
     for context_object_name, context_object in kwargs.items():
         # For each passed parameter,
         # it can be a model object or a safe value (string or number)
         is_model_object = (
-            hasattr(context_object, "id") and
-            hasattr(context_object.__class__, "__name__")
+            hasattr(context_object, 'id') and
+            hasattr(context_object.__class__, '__name__')
         )
 
         # We store a reference of the model object based on its model name,
@@ -101,15 +101,15 @@ def async_include(context, template_path, *args, **kwargs):
             app_name = (
                 ContentType.objects.get_for_model(context_object).app_label
             )
-            model_object_as_str = "{0}-{1}-{2}".format(
+            model_object_as_str = '{0}-{1}-{2}'.format(
                 app_name, model_name, object_id
             )
-            replacements["context"][context_object_name] = {
-                "type": "model",
-                "id": object_id,
-                "app_name": app_name,
-                "model": model_name,
-                "__checksum__": checksum.make(model_object_as_str)
+            replacements['context'][context_object_name] = {
+                'type': 'model',
+                'id': object_id,
+                'app_name': app_name,
+                'model': model_name,
+                '__checksum__': checksum.make(model_object_as_str)
             }
 
         elif type(context_object) == QuerySet:
@@ -123,32 +123,32 @@ def async_include(context, template_path, *args, **kwargs):
                 key=settings.SECRET_KEY[:16], data=sql_query
             )
 
-            replacements["context"][context_object_name] = {
-                "type": "QuerySet",
-                "query": encrypted_sql.decode("latin-1"),
-                "params": params,
-                "nonce": nonce.decode("latin-1"),
-                "tag": tag.decode("latin-1"),
-                "app_name": app_name,
-                "model": model_name,
+            replacements['context'][context_object_name] = {
+                'type': 'QuerySet',
+                'query': encrypted_sql.decode('latin-1'),
+                'params': params,
+                'nonce': nonce.decode('latin-1'),
+                'tag': tag.decode('latin-1'),
+                'app_name': app_name,
+                'model': model_name,
             }
 
-        # Safe values are sent "as is" to the view
+        # Safe values are sent as is to the view
         # that will render the template
         else:
-            context_object_as_str = "{0}".format(context_object)
-            replacements["context"][context_object_name] = {
-                "type": "safe_value",
-                "value": context_object,
-                "value_as_str": context_object_as_str,
-                "__checksum__": checksum.make(context_object_as_str)
+            context_object_as_str = '{0}'.format(context_object)
+            replacements['context'][context_object_name] = {
+                'type': 'safe_value',
+                'value': context_object,
+                'value_as_str': context_object_as_str,
+                '__checksum__': checksum.make(context_object_as_str)
             }
 
     # Serialization of context that will be sent
-    replacements["context"] = jsonpickle.dumps(replacements["context"])
+    replacements['context'] = jsonpickle.dumps(replacements['context'])
 
     # Pass language code
-    replacements["language_code"] = get_language()
+    replacements['language_code'] = get_language()
 
     # Render the template of this template tag
     try:
diff --git a/async_include/views.py b/async_include/views.py
@@ -19,44 +19,44 @@
 def get_template(request):
 
     # POST request is mandatory
-    if request.method != "POST":
+    if request.method != 'POST':
         return HttpResponse(status=400)
 
     json_body = jsonpickle.loads(request.body.decode('utf-8'))
-    path = json_body.get("path")
+    path = json_body.get('path')
 
     # Remote context
     # The caller has sent the model objects and
     # safe values (strings, numbers, etc.) as a dict with
     # the app_labels, model and id
-    context = json_body.get("context")
+    context = json_body.get('context')
 
     # language
-    language_code = json_body.get("language_code")
+    language_code = json_body.get('language_code')
 
     replacements = {}
 
     # For each remote context value, we load it again
     for context_object_name, context_object_load_params in context.items():
         # Type of the value
-        object_type = context_object_load_params["type"]
+        object_type = context_object_load_params['type']
 
         # If the value is a model, we load the model object and
         # include it in the template replacements
-        if object_type == "model":
-            app_name = context_object_load_params["app_name"]
-            model_name = context_object_load_params["model"]
-            object_id = context_object_load_params["id"]
+        if object_type == 'model':
+            app_name = context_object_load_params['app_name']
+            model_name = context_object_load_params['model']
+            object_id = context_object_load_params['id']
             # Loading the model
             model = apps.get_model(app_name, model_name)
             # Loading the object and including it as a replacement
             model_object = model.objects.get(id=object_id)
             # Checking if JSON has been tampered
-            model_object_as_str = "{0}-{1}-{2}".format(
+            model_object_as_str = '{0}-{1}-{2}'.format(
                 app_name, model_name, object_id
             )
             if (
-                context_object_load_params["__checksum__"] !=
+                context_object_load_params['__checksum__'] !=
                 checksum.make(model_object_as_str)
             ):
                 return HttpResponse(
@@ -68,21 +68,21 @@ def get_template(request):
             replacements[context_object_name] = model_object
 
         # If the value is a QuerySet we include it in the template replacements
-        elif object_type == "QuerySet":
+        elif object_type == 'QuerySet':
             # Loading the model
-            app_name = context_object_load_params["app_name"]
-            model_name = context_object_load_params["model"]
+            app_name = context_object_load_params['app_name']
+            model_name = context_object_load_params['model']
             model = apps.get_model(app_name, model_name)
-            params = context_object_load_params["params"]
-            nonce = context_object_load_params["nonce"]
-            tag = context_object_load_params["tag"]
+            params = context_object_load_params['params']
+            nonce = context_object_load_params['nonce']
+            tag = context_object_load_params['tag']
 
             try:
                 # Decryption of the data
                 raw_query = crypto.decrypt(
                     key=settings.SECRET_KEY[:16],
                     nonce=nonce,
-                    encrypted_data=context_object_load_params["query"],
+                    encrypted_data=context_object_load_params['query'],
                     tag=tag
                 )
 
@@ -95,18 +95,18 @@ def get_template(request):
 
         # If the value is a safe value,
         # we include it in the template replacements
-        elif object_type == "safe_value":
-            value = context_object_load_params["value"]
-            value_as_str = context_object_load_params["value_as_str"]
+        elif object_type == 'safe_value':
+            value = context_object_load_params['value']
+            value_as_str = context_object_load_params['value_as_str']
             # Checking if JSON has been tampered
             if (
-                context_object_load_params["__checksum__"] !=
+                context_object_load_params['__checksum__'] !=
                     checksum.make(value_as_str)
             ):
                 return HttpResponse(
                     status=403,
-                    content="JSON tampering detected when loading safe value "
-                            "for attribute '{0}'. Value: '{1}'".format(
+                    content='JSON tampering detected when loading safe value '
+                            'for attribute \'{0}\'. Value: \'{1}\''.format(
                                 context_object_name, value_as_str
                             ),
                     content_type='text/plain'
