Implement importing unrelated package

betterproto/compile/importing.py

@@ -1,3 +1,4 @@
+from functools import reduce
 from typing import Dict, List, Type
 
 import stringcase
@@ -80,9 +81,17 @@ def get_ref_type(
     name    = foo.bar.Baz
     '''
     if importing_package[0:len(current_package)] == current_package:
-        relative_importing_package = '.'.join(importing_package[len(current_package):])
+        importing_descendent = importing_package[len(current_package):]
-        imports.add(f"from . import {relative_importing_package}")
+        string_from = '.'.join(importing_descendent[0:-1])
-        return f"{relative_importing_package}.{importing_type}"
+        string_import = importing_descendent[-1]
+
+        if string_from:
+            string_alias = '_'.join(importing_descendent)
+            imports.add(f"from .{string_from} import {string_import} as {string_alias}")
+            return f"{string_alias}.{importing_type}"
+        else:
+            imports.add(f"from . import {string_import}")
+            return f"{string_import}.{importing_type}"
 
     # importing parent & ancestor
     '''
@@ -95,6 +104,10 @@ def get_ref_type(
     package = foo.bar.baz
     name    = Bar
     '''
+    if current_package[0:len(importing_package)] == importing_package:
+        distance = len(current_package) - len(importing_package)
+        imports.add(f"from .{'.' * distance} import {importing_type}")
+        return importing_type
 
     # importing unrelated or cousin
     '''
@@ -104,6 +117,13 @@ def get_ref_type(
     package = foo.bar.baz
     name    = foo.example.Bar
     '''
+    root_distance = len(current_package)
+    shared_ancestory_length = reduce(lambda l, pair: l + (pair[0] == pair[1]), zip(current_package, importing_package), 0)
 
-    return None
+    string_from = f"{'.' * (shared_ancestory_length+1)}.{'.'.join(importing_package[0:-1])}"
+    string_import = importing_package[-1]
+    string_alias = '_' * root_distance + safe_snake_case('.'.join(importing_package))
+    imports.add(f"from {string_from} import {string_import} as {string_alias}")
+
+    return f"{string_alias}.{importing_type}"
     # return type_name

betterproto/tests/test_get_ref_type.py

@@ -141,6 +141,30 @@ def test_import_deeply_nested_child_from_package():
     assert name == "deeply_nested_child.Message"
 
 
+def test_import_root_sibling():
+    imports = set()
+    name = get_ref_type(package="", imports=imports, type_name="Message")
+
+    assert imports == {"from . import Message"}
+    assert name == "Message"
+
+
+def test_import_nested_siblings():
+    imports = set()
+    name = get_ref_type(package="foo", imports=imports, type_name="foo.Message")
+
+    assert imports == {"from . import Message"}
+    assert name == "Message"
+
+
+def test_import_deeply_nested_siblings():
+    imports = set()
+    name = get_ref_type(package="foo.bar", imports=imports, type_name="foo.bar.Message")
+
+    assert imports == {"from . import Message"}
+    assert name == "Message"
+
+
 def test_import_parent_package_from_child():
     imports = set()
     name = get_ref_type(
@@ -181,25 +205,25 @@ def test_import_root_package_from_deeply_nested_child():
     assert name == "Message"
 
 
-def test_import_root_sibling():
+def test_import_unrelated_package():
     imports = set()
-    name = get_ref_type(package="", imports=imports, type_name="Message")
+    name = get_ref_type(package="a", imports=imports, type_name="b.Message")
 
-    assert imports == {"from . import Message"}
+    assert imports == {"from .. import b as _b"}
-    assert name == "Message"
+    assert name == "_b.Message"
 
 
-def test_import_nested_siblings():
+def test_import_cousin_package():
     imports = set()
-    name = get_ref_type(package="foo", imports=imports, type_name="foo.Message")
+    name = get_ref_type(package="a.a", imports=imports, type_name="a.b.Message")
 
-    assert imports == {"from . import Message"}
+    assert imports == {"from .. import b as __b"}
-    assert name == "Message"
+    assert name == "__b.Message"
 
 
-def test_import_deeply_nested_siblings():
+def test_import_far_cousin_package():
     imports = set()
-    name = get_ref_type(package="foo.bar", imports=imports, type_name="foo.bar.Message")
+    name = get_ref_type(package="a.a.a", imports=imports, type_name="a.b.c.Message")
 
-    assert imports == {"from . import Message"}
+    assert imports == {"from ... import c as ___c"}
-    assert name == "Message"
+    assert name == "___c.Message"