Python lint errors

Author: Rangababu-R

openapiart/generator.py

@@ -704,7 +704,7 @@ def _get_external_field_name(self, openapi_name):
         if external in ["String"]:
             external += "_"
         return external
-    
+
     def _small_first_char(self, words):
         if isinstance(words, list):
             ret = []
@@ -732,7 +732,7 @@ def _write_openapi_object(self, ref, choice_method_name=None):
             if "choice" in self._get_choice_names(schema_object):
                 slots.append("'_choice'")
             self._write(1, "__slots__ = (%s)" % ",".join(slots))
-            self._write(1, "_JSON_NAME = \"%s\"" % json_name)
+            self._write(1, '_JSON_NAME = "%s"' % json_name)
 
             # write _TYPES definition
             # TODO: this func won't detect whether $ref for a given property is
@@ -1081,7 +1081,11 @@ def _write_openapilist_special_methods(
         self._write()
         self._write(1, "def _instanceOf(self, item):")
         self._write(2, "if not isinstance(item, %s):" % (contained_class_name))
-        self._write(3, "raise Exception(\"Item is not an instance of %s\")" % (contained_class_name))
+        self._write(
+            3,
+            'raise Exception("Item is not an instance of %s")'
+            % (contained_class_name),
+        )
 
     def _write_factory_method(
         self,

openapiart/openapiartgo.py

@@ -431,7 +431,9 @@ def _build_api_interface(self):
                     new.schema_name = self._get_schema_object_name_from_ref(
                         ref[0].value
                     )
-                    new.schema_raw_name = self._get_schema_json_name_from_ref(ref[0].value)
+                    new.schema_raw_name = self._get_schema_json_name_from_ref(
+                        ref[0].value
+                    )
                     new.schema_object = self._get_schema_object_from_ref(
                         ref[0].value
                     )
@@ -1065,7 +1067,7 @@ def _write_interface(self, new):
                 }}
                 return str
             }}
-            
+
             func (obj *{struct}) Clone() ({interface}, error) {{
                 newObj := New{interface}()
                 pbText, err := obj.ToPbText()
@@ -1086,7 +1088,7 @@ def _write_interface(self, new):
                 if len(internal_items) == 0
                 else "\n".join(internal_items),
                 nil_call="obj.setNil()" if len(internal_items_nil) > 0 else "",
-                obj_name=new.schema_raw_name
+                obj_name=new.schema_raw_name,
             )
         )
         if len(internal_items_nil) > 0:
@@ -1782,8 +1784,12 @@ def _build_setters_getters(self, fluent_new):
                 if field.type == "[]byte":
                     field.name = "Bytes"
                 elif "$ref" in property_schema:
-                    schema_name = self._get_schema_object_name_from_ref(property_schema["$ref"])
-                    field.schema_name = self._get_schema_json_name_from_ref(property_schema["$ref"])
+                    schema_name = self._get_schema_object_name_from_ref(
+                        property_schema["$ref"]
+                    )
+                    field.schema_name = self._get_schema_json_name_from_ref(
+                        property_schema["$ref"]
+                    )
                     field.name = self._get_external_struct_name(schema_name)
             field.isOptional = fluent_new.isOptional(property_name)
             field.isPointer = (
@@ -1988,7 +1994,7 @@ def _validate_types(self, new, field):
                 validation = append(validation,
                 fmt.Sprintf("required field `%s.{field_name}` must not be empty", path))
             }} """.format(
-                name=field.name, intf_name=new.schema_raw_name,
+                name=field.name,
                 field_name=field.schema_name,
                 value=0 if field.isEnum and field.isArray is False else value,
                 enum=".Number()"
@@ -2020,7 +2026,9 @@ def _validate_types(self, new, field):
             ).format(
                 name=field.schema_name,
                 interface=new.schema_raw_name,
-                max="max({})".format(field.type.lstrip("[]")) if field.max is None else field.max,
+                max="max({})".format(field.type.lstrip("[]"))
+                if field.max is None
+                else field.max,
                 pointer="*" if field.isPointer else "",
                 min="min({})".format(field.type.lstrip("[]"))
                 if field.min is None
@@ -2059,7 +2067,9 @@ def _validate_types(self, new, field):
                 ).format(
                     name=field.schema_name,
                     interface=new.schema_name,
-                    max_length="any" if field.max_length is None else field.max_length,
+                    max_length="any"
+                    if field.max_length is None
+                    else field.max_length,
                     pointer="*" if field.isPointer else "",
                     min_length=field.min_length
                     if field.min_length is None
@@ -2090,11 +2100,12 @@ def _validate_types(self, new, field):
                         validation = append(validation, err.Error())
                     }}
                 """.format(
-                        name=field.name, interface=new.schema_name,
-                        field_name=field.schema_name,
-                        format=field.format.capitalize() if field.isArray is False
-                        else field.format.capitalize() + "Slice",
-                    )
+                    name=field.name,
+                    field_name=field.schema_name,
+                    format=field.format.capitalize()
+                    if field.isArray is False
+                    else field.format.capitalize() + "Slice",
+                )
         # Enum will be handled via wrapper lib
         if inner_body == "":
             return body
@@ -2117,12 +2128,15 @@ def _validate_struct(self, new, field):
                         validation,
                         fmt.Sprintf("required field `%s.{field_name}` must not be empty", path))
                 }}
-            """.format(name=field.name, interface=new.schema_raw_name, field_name=field.schema_name)
+            """.format(
+                name=field.name,
+                field_name=field.schema_name,
+            )
 
         inner_body = """obj.{external_name}().validateObj(
             set_default, fmt.Sprintf("%s.{json_name}", path))""".format(
             external_name=self._get_external_struct_name(field.name),
-            json_name=field.schema_name
+            json_name=field.schema_name,
         )
         if field.isArray:
             inner_body = """
@@ -2138,8 +2152,6 @@ def _validate_struct(self, new, field):
             """.format(
                 name=field.name,
                 field_name=field.schema_name,
-                field_type=field.type,
-                internal_items_name="{}Slice".format(field.struct),
                 field_internal_struct=field.struct,
             )
         body += """
@@ -2384,13 +2396,13 @@ def _write_default_method(self, new):
                 struct=new.struct, body=body
             )
         )
-    
+
     def _get_schema_json_name_from_ref(self, ref):
         final_piece = ref.split("/")[-1]
         if "." in final_piece:
             return final_piece.replace(".", "_").lower()
         return self._lower_first_char(final_piece)
-    
+
     def _lower_first_char(self, word):
         return word[0].lower() + word[1:]
 

openapiart/tests/test_formats.py

@@ -20,7 +20,7 @@ def test_formats_bad_string(config, value):
     config.l.string_param = value
     try:
         config.deserialize(config.serialize(encoding=config.YAML))
-        pytest.fail("Value {value} was successfully validated".format(value))
+        pytest.fail("Value {} was successfully validated".format(value))
     except Exception:
         pass
 
@@ -50,7 +50,7 @@ def test_formats_good_ipv4(config, value):
     config.l.ipv4 = value
     try:
         config.deserialize(config.serialize(encoding=config.YAML))
-    except Exception as e:
+    except Exception:
         pytest.fail("Value {} was not valid".format(value))
 
 

openapiart/tests/test_func.py

@@ -139,8 +139,11 @@ def test_x_pattern_integer_good_and_bad_list(default_config, integer):
         default_config.integer_pattern.serialize(default_config.DICT)
         pytest.fail("integer values got serialize")
     except Exception as e:
-        if "`abcd::abcd::`" not in str(e) \
-            or "`256`" not in str(e) or "`ab:ab:ab:ab:ab:ab`" not in str(e):
+        if (
+            "`abcd::abcd::`" not in str(e)
+            or "`256`" not in str(e)
+            or "`ab:ab:ab:ab:ab:ab`" not in str(e)
+        ):
             pytest.fail("Invalid integer list is not proper in error message")
 
 
@@ -160,7 +163,7 @@ def test_x_pattern_good_inc_dec(default_config, index, direction):
     dir_obj.count = count[index]
     try:
         default_config.serialize(default_config.DICT)
-    except Exception as e:
+    except Exception:
         pytest.fail("%s with %s Failed to serialize" % (enum, direction))
 
 
@@ -211,4 +214,3 @@ def test_enum_setter(api, default_config):
 
 if __name__ == "__main__":
     pytest.main(["-v", "-s", __file__])
-

openapiart/tests/test_py_go_diff.py

@@ -1,5 +1,6 @@
 import importlib
 import pytest
+
 module = importlib.import_module("sanity")
 
 
@@ -31,16 +32,26 @@ def test_validation_errors():
         assert "required field `prefix_config.a` must not be empty" in str(e)
         assert "required field `prefix_config.b` must not be empty" in str(e)
         assert "required field `prefix_config.c` must not be empty" in str(e)
-        assert "required field `prefix_config.required_object` must not be empty" in str(e)
-        assert "required field `prefix_config.e.e_a` must not be empty" in str(e)
-        assert "required field `prefix_config.e.e_b` must not be empty" in str(e)
-    
+        assert (
+            "required field `prefix_config.required_object` must not be empty"
+            in str(e)
+        )
+        assert "required field `prefix_config.e.e_a` must not be empty" in str(
+            e
+        )
+        assert "required field `prefix_config.e.e_b` must not be empty" in str(
+            e
+        )
+
     p.e.e_a = "abc"
     try:
         p.validate()
     except Exception as e:
         print(e)
-        assert "value of `prefix_config.e.e_a` must be a valid float type, instead of `abc`" in str(e)
+        assert (
+            "value of `prefix_config.e.e_a` must be a valid float type, instead of `abc`"
+            in str(e)
+        )
     p.a = "abc"
     p.b = 10.1
     p.c = 20
@@ -51,15 +62,33 @@ def test_validation_errors():
     p.ipv4_pattern.ipv4.value = "1.1"
     errors = p._validate(p._JSON_NAME, True)
     assert len([True for e in errors if ".e_b` must not be empty" in e]) == 2
-    assert "required field `prefix_config.j[0].e_a` must not be empty" in errors
+    assert (
+        "required field `prefix_config.j[0].e_a` must not be empty" in errors
+    )
     assert "required field `prefix_config.e.e_b` must not be empty" in errors
-    assert "value of `prefix_config.e.e_a` must be a valid float type, instead of `abc`" in errors
-    assert "required field `prefix_config.j[0].e_a` must not be empty" in errors
-    assert "required field `prefix_config.j[0].e_b` must not be empty" in errors
-    assert "value of `prefix_config.mac_pattern.mac.values[0]` must be a valid mac address, instead of `1`" in errors
-    assert "value of `prefix_config.mac_pattern.mac.values[1]` must be a valid mac address, instead of `20`" in errors
-    assert "value of `prefix_config.ipv4_pattern.ipv4.value` must be a valid ipv4 address, instead of `1.1`" in errors
-    
+    assert (
+        "value of `prefix_config.e.e_a` must be a valid float type, instead of `abc`"
+        in errors
+    )
+    assert (
+        "required field `prefix_config.j[0].e_a` must not be empty" in errors
+    )
+    assert (
+        "required field `prefix_config.j[0].e_b` must not be empty" in errors
+    )
+    assert (
+        "value of `prefix_config.mac_pattern.mac.values[0]` must be a valid mac address, instead of `1`"
+        in errors
+    )
+    assert (
+        "value of `prefix_config.mac_pattern.mac.values[1]` must be a valid mac address, instead of `20`"
+        in errors
+    )
+    assert (
+        "value of `prefix_config.ipv4_pattern.ipv4.value` must be a valid ipv4 address, instead of `1.1`"
+        in errors
+    )
+
 
 def test_enum_setter():
     p = module.Api().prefix_config()