Test to_hash_string;

Rearrange and refactor code;

Author: bogdandm

rest_client_gen/dynamic_typing/__init__.py

@@ -1,5 +1,5 @@
 from .base import (
-    BaseType, ImportPathList, MetaData, NoneType, Unknown, UnknownType
+    BaseType, ImportPathList, MetaData, NoneType, Unknown, UnknownType, get_hash_string
 )
 from .complex import ComplexType, DList, DOptional, DTuple, DUnion, SingleType
 from .models_meta import AbsoluteModelRef, ModelMeta, ModelPtr

rest_client_gen/dynamic_typing/base.py

@@ -1,3 +1,4 @@
+from inspect import isclass
 from typing import Iterable, List, Tuple, Union
 
 ImportPathList = List[Tuple[str, Union[Iterable[str], str, None]]]
@@ -31,10 +32,22 @@ def to_typing_code(self) -> Tuple[ImportPathList, str]:
     def to_hash_string(self) -> str:
         """
         Return unique string that can be used to generate hash of type instance.
+        Caches hash value by default. If subclass can mutate (by default it always can)
+        then it should define setters to safely invalidate cached value.
 
         :return: hash string
         """
-        # NOTE: Do not override __hash__ function as BaseType instances could mutate
+        # NOTE: Do not override __hash__ function because BaseType instances isn't immutable
+        if not self._hash:
+            self._hash = self._to_hash_string()
+        return self._hash
+
+    def _to_hash_string(self) -> str:
+        """
+        Hash getter method to override
+
+        :return:
+        """
         raise NotImplementedError()
 
 
@@ -60,3 +73,12 @@ def to_hash_string(self) -> str:
 Unknown = UnknownType()
 NoneType = type(None)
 MetaData = Union[type, dict, BaseType]
+
+
+def get_hash_string(t: MetaData):
+    if isinstance(t, dict):
+        return str(hash(tuple((k, get_hash_string(v)) for k, v in t.items())))
+    elif isclass(t):
+        return str(t)
+    elif isinstance(t, BaseType):
+        return t.to_hash_string()

rest_client_gen/dynamic_typing/complex.py

@@ -1,22 +1,12 @@
-from inspect import isclass
 from itertools import chain
 from typing import Iterable, List, Tuple, Union
 
-from .base import BaseType, ImportPathList, MetaData
+from .base import BaseType, ImportPathList, MetaData, get_hash_string
 from .typing import metadata_to_typing
 
 
-def get_hash_string(t: MetaData):
-    if isinstance(t, dict):
-        return str(hash(tuple((k, get_hash_string(v)) for k, v in t.items())))
-    elif isclass(t):
-        return str(t)
-    elif isinstance(t, BaseType):
-        return t.to_hash_string()
-
-
 class SingleType(BaseType):
-    __slots__ = ["_type"]
+    __slots__ = ["_type", "_hash"]
 
     def __init__(self, t: MetaData):
         self._type = t
@@ -47,14 +37,12 @@ def replace(self, t: 'MetaData', **kwargs) -> 'SingleType':
         self.type = t
         return self
 
-    def to_hash_string(self) -> str:
-        if not self._hash:
-            self._hash = f"{type(self).__name__}/{get_hash_string(self.type)}"
-        return self._hash
+    def _to_hash_string(self) -> str:
+        return f"{type(self).__name__}/{get_hash_string(self.type)}"
 
 
 class ComplexType(BaseType):
-    __slots__ = ["_types"]
+    __slots__ = ["_types", "_sorted", "_hash"]
 
     def __init__(self, *types: MetaData):
         self._types = list(types)
@@ -125,10 +113,8 @@ def to_typing_code(self) -> Tuple[ImportPathList, str]:
             f"[{nested}]"
         )
 
-    def to_hash_string(self) -> str:
-        if not self._hash:
-            self._hash = type(self).__name__ + "/" + ",".join(map(get_hash_string, self.types))
-        return self._hash
+    def _to_hash_string(self) -> str:
+        return type(self).__name__ + "/" + ",".join(map(get_hash_string, self.types))
 
 
 class DOptional(SingleType):

rest_client_gen/dynamic_typing/models_meta.py

@@ -121,6 +121,7 @@ def replace(self, t: ModelMeta, **kwargs) -> 'ModelPtr':
         return self
 
     def replace_parent(self, t: ModelMeta, **kwargs) -> 'ModelPtr':
+        self._hash = None
         self.parent.remove_child_ref(self)
         self.parent = t
         self.parent.add_child_ref(self)
@@ -129,7 +130,7 @@ def replace_parent(self, t: ModelMeta, **kwargs) -> 'ModelPtr':
     def to_typing_code(self) -> Tuple[ImportPathList, str]:
         return AbsoluteModelRef(self.type).to_typing_code()
 
-    def to_hash_string(self) -> str:
+    def _to_hash_string(self) -> str:
         return f"{type(self).__name__}_#{self.type.index}"
 
 
@@ -153,6 +154,11 @@ class NestedModel:
     This information is only available at the models code generation stage
     while typing code is generated from raw metadata and passing this absolute path as argument
     to each ModelPtr would be annoying.
+
+    Usage:
+
+    with AbsoluteModelRef.inject({TestModel: "ParentModelName"}):
+        <some code generation>
     """
 
     class Context:

test/test_dynamic_typing/test_dynamic_typing.py

@@ -1,9 +1,11 @@
+from builtins import complex
+
 import pytest
 
-from rest_client_gen.dynamic_typing import DUnion
+from rest_client_gen.dynamic_typing import DUnion, get_hash_string
 
 # *args | MetaData
-test_dunion= [
+test_dunion = [
     pytest.param(
         [int, int],
         DUnion(int),
@@ -21,7 +23,21 @@
     )
 ]
 
+
 @pytest.mark.parametrize("value,expected", test_dunion)
 def test_dunion_creation(value, expected):
     result = DUnion(*value)
-    assert result == expected
+    assert result == expected
+
+
+def test_hash_string():
+    a = {'a': int}
+    b = {'b': int}
+    c = {'a': float}
+    assert len(set(map(get_hash_string, (a, b, c)))) == 3
+
+    union = DUnion(str, float)
+    h1 = union.to_hash_string()
+    union.replace(complex, index=0)
+    h2 = union.to_hash_string()
+    assert h1 != h2, f"{h1}, {h2}"