use module names to prevent same name duplicate errors

devdoomari · devdoomari3 · commit fbacfe8137ba · 2020-08-08T21:36:36.000+09:00
diff --git a/py_type_extractor/type_extractor/__tests__/test_class_of_generic_instance.py b/py_type_extractor/type_extractor/__tests__/test_class_of_generic_instance.py
@@ -46,9 +46,13 @@ def test_class_of_generic_instance():
             'some_property': int,
         }
     )
-    assert collected_types['SomeGenericClass'] == some_generic_class
+    assert collected_types[
+       'py_type_extractor.test_fixtures.generic_classes.SomeGenericClass'
+   ] == some_generic_class
 
-    assert collected_types['SomeClass'] == some_class
+    assert collected_types[
+       'py_type_extractor.test_fixtures.generic_classes.SomeClass'
+   ] == some_class
 
     assert collected_types['some_func_with_generic_inst'] == FunctionFound(
         name='some_func_with_generic_inst',
diff --git a/py_type_extractor/type_extractor/__tests__/test_class_of_generic_origin.py b/py_type_extractor/type_extractor/__tests__/test_class_of_generic_origin.py
@@ -26,7 +26,7 @@ def test_class_of_generic_origin():
         original=SomeTypeVarB,
     )
     assert classes == {
-        'SomeGenericClass': ClassFound(
+        'py_type_extractor.test_fixtures.generic_classes.SomeGenericClass': ClassFound(
             name='SomeGenericClass',
             fields={
                 'a': typevar_A,
diff --git a/py_type_extractor/type_extractor/__tests__/test_class_with_union_field.py b/py_type_extractor/type_extractor/__tests__/test_class_with_union_field.py
@@ -25,7 +25,7 @@ def test_class_with_union_field():
         if isinstance(value, ClassFound)
     }
     assert classes == {
-        'ClassWithUnionField': ClassFound(
+        'py_type_extractor.test_fixtures.union_type_class.ClassWithUnionField': ClassFound(
             name='ClassWithUnionField',
             fields={
                 'cwufField1': TypeOR(
diff --git a/py_type_extractor/type_extractor/__tests__/test_classes_with_inheritance.py b/py_type_extractor/type_extractor/__tests__/test_classes_with_inheritance.py
@@ -28,9 +28,9 @@ def test_classes_with_inheritance():
         },
     )
     assert classes == {
-        'ParentClassA': parent_class_a,
-        'ParentClassB': parent_class_b,
-        'ChildClass': ClassFound(
+        'py_type_extractor.test_fixtures.classes_with_inheritance.ParentClassA': parent_class_a,
+        'py_type_extractor.test_fixtures.classes_with_inheritance.ParentClassB': parent_class_b,
+        'py_type_extractor.test_fixtures.classes_with_inheritance.ChildClass': ClassFound(
             name='ChildClass',
             fields={
                 'b': str,
diff --git a/py_type_extractor/type_extractor/__tests__/test_func_with_nested_arg_class.py b/py_type_extractor/type_extractor/__tests__/test_func_with_nested_arg_class.py
@@ -19,7 +19,12 @@ class ParentClass:
     def func_with_nested_arg_class(a: ParentClass) -> ParentClass:
         return a
 
-    cleanedup = traverse(type_collector.collected_types[ParentClass.__name__], cleanup)
+    cleanedup = traverse(
+        type_collector.collected_types[
+            'py_type_extractor.type_extractor.__tests__.test_func_with_nested_arg_class.ParentClass'
+        ],
+        cleanup,
+    )
 
     child_class = ClassFound(
         name='ChildClass',
@@ -45,4 +50,4 @@ def func_with_nested_arg_class(a: ParentClass) -> ParentClass:
         class_raw=ParentClass
     )
     parent_cleaned = traverse(parent_class, cleanup)
-    assert(parent_cleaned == cleanedup)
+    assert (parent_cleaned == cleanedup)
diff --git a/py_type_extractor/type_extractor/__tests__/test_newtype.py b/py_type_extractor/type_extractor/__tests__/test_newtype.py
@@ -37,7 +37,7 @@ def test_newtype():
             },
             return_type=str,
         ),
-        'SomeClass': some_class,
+        'py_type_extractor.test_fixtures.new_type.SomeClass': some_class,
         'SomeClassInNewType': NewTypeFound(
             name='SomeClassInNewType',
             actual=some_class,
diff --git a/py_type_extractor/type_extractor/__tests__/test_pydantic_classes.py b/py_type_extractor/type_extractor/__tests__/test_pydantic_classes.py
@@ -1,16 +1,13 @@
-from pydantic import BaseModel
-
 from py_type_extractor.type_extractor.nodes.ClassFound import ClassFound
 from py_type_extractor.type_extractor.__tests__.utils import traverse, cleanup
-from py_type_extractor.type_extractor.nodes.DictFound import DictFound
 from py_type_extractor.type_extractor.type_extractor import TypeExtractor
 from py_type_extractor.test_fixtures.pydantic_classes import (
     SomePydanticDataClass,
     SomePydanticModelClass,
 )
 
 
-def test_various_classes():
+def test_pydantic_classes():
     type_extractor = TypeExtractor()
     type_extractor.add(None)(SomePydanticModelClass)
     type_extractor.add(None)(SomePydanticDataClass)
@@ -21,19 +18,23 @@ def test_various_classes():
         for (key, value) in type_extractor.collected_types.items()
         if isinstance(value, ClassFound)
     }
-    assert classes['SomePydanticDataClass'] == ClassFound(
+    assert classes[
+        'py_type_extractor.test_fixtures.pydantic_classes.SomePydanticDataClass'
+    ] == ClassFound(
         name='SomePydanticDataClass',
         fields={
             'a': int,
             'b': str,
         },
     )
 
-    assert classes['SomePydanticModelClass'] == ClassFound(
+    assert classes[
+        'py_type_extractor.test_fixtures.pydantic_classes.SomePydanticModelClass'
+    ] == ClassFound(
         name='SomePydanticModelClass',
         fields={
             'c': int,
             'something': float,
         },
-        base_classes=[classes['BaseModel']],
+        base_classes=[classes['pydantic.main.BaseModel']],
     )
diff --git a/py_type_extractor/type_extractor/__tests__/test_various_classes.py b/py_type_extractor/type_extractor/__tests__/test_various_classes.py
@@ -21,20 +21,20 @@ def test_various_classes():
         if isinstance(value, ClassFound)
     }
     assert classes == {
-        'SomeDataClass': ClassFound(
+        'py_type_extractor.test_fixtures.various_classes.SomeDataClass': ClassFound(
             name='SomeDataClass',
             fields={
                 'sdcArg1': int,
                 'sdcArg2': str,
             },
         ),
-        'SomeNormalClass': ClassFound(
+        'py_type_extractor.test_fixtures.various_classes.SomeNormalClass': ClassFound(
             name='SomeNormalClass',
             fields={
                 'checklist': DictFound(key=str, value=bool),
             },
         ),
-        'SomeNamedTuple': ClassFound(
+        'py_type_extractor.test_fixtures.various_classes.SomeNamedTuple': ClassFound(
             name='SomeNamedTuple',
             fields={
                 'sntArg1': int,
diff --git a/py_type_extractor/type_extractor/middlewares/class_found.py b/py_type_extractor/type_extractor/middlewares/class_found.py
@@ -23,7 +23,12 @@ def class_found_middleware(
             or isinstance(_class, _TypedDictMeta):
         return None
 
-    duplicate = type_extractor.collected_types.get(_class.__name__)
+    module = inspect.getmodule(_class)
+    module_name = module.__name__
+
+    name = _class.__name__
+
+    duplicate = type_extractor.collected_types.get(f"{module_name}.{name}")
     if duplicate is not None:
         assert isinstance(duplicate, ClassFound) \
                and duplicate.class_raw == _class
@@ -41,7 +46,7 @@ def class_found_middleware(
     ])
 
     argspec = inspect.getfullargspec(_data_class)
-    module = inspect.getmodule(_class)
+
     filename = module and module.__file__
     annotations: Dict = getattr(_class, '__annotations__', argspec.annotations)
     fields = type_extractor.params_to_nodes(annotations, annotations.keys())
@@ -51,7 +56,7 @@ def class_found_middleware(
         list(typing_inspect.get_parameters(_class))
     ]
     class_found = ClassFound(
-        name=_class.__name__,
+        name=name,
         class_raw=_class,
         filePath=filename,
         base_classes=base_classes,
@@ -62,5 +67,5 @@ def class_found_middleware(
         type_vars=type_vars,
     )
 
-    type_extractor.collected_types[class_found.name] = class_found
+    type_extractor.collected_types[f"{module_name}.{name}"] = class_found
     return class_found

Original file line number	Diff line number	Diff line change
`@@ -46,9 +46,13 @@ def test_class_of_generic_instance():`
`46`	`46`	`'some_property': int,`
`47`	`47`	`}`
`48`	`48`	`)`
`49`		`- assert collected_types['SomeGenericClass'] == some_generic_class`
	`49`	`+ assert collected_types[`
	`50`	`+ 'py_type_extractor.test_fixtures.generic_classes.SomeGenericClass'`
	`51`	`+ ] == some_generic_class`
`50`	`52`
`51`		`- assert collected_types['SomeClass'] == some_class`
	`53`	`+ assert collected_types[`
	`54`	`+ 'py_type_extractor.test_fixtures.generic_classes.SomeClass'`
	`55`	`+ ] == some_class`
`52`	`56`
`53`	`57`	`assert collected_types['some_func_with_generic_inst'] == FunctionFound(`
`54`	`58`	`name='some_func_with_generic_inst',`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ def test_class_of_generic_origin():`
`26`	`26`	`original=SomeTypeVarB,`
`27`	`27`	`)`
`28`	`28`	`assert classes == {`
`29`		`- 'SomeGenericClass': ClassFound(`
	`29`	`+ 'py_type_extractor.test_fixtures.generic_classes.SomeGenericClass': ClassFound(`
`30`	`30`	`name='SomeGenericClass',`
`31`	`31`	`fields={`
`32`	`32`	`'a': typevar_A,`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ def test_class_with_union_field():`
`25`	`25`	`if isinstance(value, ClassFound)`
`26`	`26`	`}`
`27`	`27`	`assert classes == {`
`28`		`- 'ClassWithUnionField': ClassFound(`
	`28`	`+ 'py_type_extractor.test_fixtures.union_type_class.ClassWithUnionField': ClassFound(`
`29`	`29`	`name='ClassWithUnionField',`
`30`	`30`	`fields={`
`31`	`31`	`'cwufField1': TypeOR(`