Update name property;

Extract generic functions;
Names merging at models merge stage;

Author: bogdandm

rest_client_gen/models_meta.py

@@ -3,6 +3,7 @@
 import inflection
 
 from .dynamic_typing import MetaData, SingleType
+from .utils import distinct_words
 
 try:
     # https://www.clips.uantwerpen.be/pages/pattern-en#pluralization
@@ -27,6 +28,7 @@ def __init__(self, t: MetaData, index, _original_fields=None):
         self.index = index
         self.pointers: Set[ModelPtr] = set()
         self._name: Optional[str] = None
+        self._name_generated: Optional[bool] = None
 
     def __str__(self):
         return f"Model#{self.index}" + ("-" + self._name if self._name else "")
@@ -40,39 +42,44 @@ def __eq__(self, other):
     def __hash__(self):
         return hash(self.index)
 
-    def update_base_name(self):
+    def generate_name(self):
         # TODO: Tests
-        base_names = {singularize(inflection.underscore(ptr.parent_field_name))
-                      for ptr in self.pointers if ptr.parent is not None}
-        filtered_names = set()
-        for name in base_names:
-            for other in list(filtered_names):
-                if name in other:
-                    filtered_names.add(name)
-                    filtered_names.remove(other)
-                    break
-                elif other in name:
-                    break
-            else:
-                filtered_names.add(name)
-        names = [inflection.camelize(name)
-                 for name in sorted(filtered_names)]
-        self._name = "_".join(names)
+        base_names = (singularize(inflection.underscore(ptr.parent_field_name))
+                      for ptr in self.pointers if ptr.parent is not None)
+        filtered_names = distinct_words(*base_names)
+        new_name = self.name_joiner(*map(inflection.camelize, sorted(filtered_names)))
+        if new_name:
+            self._name = new_name
+            self._name_generated = True
+
+    @classmethod
+    def name_joiner(cls, *names: str) -> str:
+        return "_".join(names)
 
     @property
-    def base_name(self) -> str:
-        if self._name is None:
-            self.update_base_name()
+    def name(self) -> str:
+        # if self._name is None:
+        #     self.generate_name()
         return self._name
 
-    @base_name.setter
-    def base_name(self, value: str):
+    @name.setter
+    def name(self, name: str):
+        value = inflection.camelize(singularize(name))
         self._name = value
+        self._name_generated = False
 
-    @base_name.deleter
-    def base_name(self):
+    @name.deleter
+    def name(self):
         self._name = None
 
+    def set_raw_name(self, name):
+        self._name = name
+        self._name_generated = False
+
+    @property
+    def is_name_generated(self):
+        return self._name_generated
+
     def connect(self, ptr: 'ModelPtr'):
         self.pointers.add(ptr)
 

rest_client_gen/registry.py

@@ -6,7 +6,7 @@
 
 from .dynamic_typing import BaseType, MetaData
 from .models_meta import ModelMeta, ModelPtr
-from .utils import Index
+from .utils import Index, distinct_words
 
 
 class ModelCmp:
@@ -144,12 +144,18 @@ def merge_models(self, generator, strict=False) -> List[Tuple[ModelMeta, Set[Mod
 
     def _merge(self, generator, *models: ModelMeta):
         original_fields = list(chain(model.original_fields for model in models))
+        originals_names = []
         fields = OrderedSet()
         for model in models:
             fields.update(model.type.keys())
+            if not model.is_name_generated and model.name:
+                originals_names.append(model.name)
+        originals_names = distinct_words(*originals_names)
 
         metadata = generator.merge_field_sets([model.type for model in models])
         model_meta = ModelMeta(metadata, self._index(), original_fields)
+        if originals_names:
+            model_meta.name = ModelMeta.name_joiner(*originals_names)
         for model in models:
             self._unregister(model)
             for ptr in tuple(model.pointers):

rest_client_gen/utils.py

@@ -1,4 +1,5 @@
 import json
+from typing import Set
 
 
 class Index:
@@ -16,5 +17,30 @@ def __call__(self, *args, **kwargs):
             self.i += 1
         return value
 
+
 def json_format(x) -> str:
-    return json.dumps(x, indent=4, default=str, ensure_ascii=False)
+    return json.dumps(x, indent=4, default=str, ensure_ascii=False)
+
+
+def distinct_words(*words: str) -> Set[str]:
+    """
+    Filters strings so only unique strings without extended ones will be exists in resulted set, e.g.
+    >>> distinct_words('test', 'another_test', 'foo', 'qwerty_foo_bar')
+    {'test', 'foo'}
+
+    :param words:
+    :return:
+    """
+    words = set(words)
+    filtered_words = set()
+    for name in words:
+        for other in list(filtered_words):
+            if name in other:
+                filtered_words.add(name)
+                filtered_words.remove(other)
+                break
+            elif other in name:
+                break
+        else:
+            filtered_words.add(name)
+    return filtered_words

testing_tools/real_apis/f1.py

@@ -1,6 +1,7 @@
 """
 Example uses Ergast Developer API (http://ergast.com/mrd/)
 """
+import inflection
 import requests
 
 from rest_client_gen.generator import Generator
@@ -27,31 +28,29 @@ def driver_standings(season='current', round_code='last'):
 def main():
     results_data = results()
     dump_response("f1", "results", results_data)
+    results_data = ("results", results_data)
 
     drivers_data = drivers()
     dump_response("f1", "drivers", drivers_data)
+    drivers_data = ("drivers", drivers_data)
 
     driver_standings_data = driver_standings()
     dump_response("f1", "driver_standings", driver_standings_data)
+    driver_standings_data = ("driver_standings", driver_standings_data)
 
     gen = Generator()
     reg = ModelRegistry()
-    for data in (results_data, drivers_data, driver_standings_data):
+    for name, data in (results_data, drivers_data, driver_standings_data):
         fields = gen.generate(*data)
-        model = reg.process_meta_data(fields)
-        print(pretty_format_meta(model))
+        model_ptr = reg.process_meta_data(fields)
+        model_ptr.type.set_raw_name(inflection.camelize(name))
+    reg.merge_models(generator=gen)
+    for model in reg.models:
+        model.generate_name()
 
-    result = reg.merge_models(generator=gen)
-    for model, group in result:
-        print("\n" + "=" * 20, end='')
+    for model in reg.models:
         print(pretty_format_meta(model))
-
-        print("\n" + "-" * 10 + " replaces " + "-" * 10, end='')
-        for old_model in group:
-            print(pretty_format_meta(old_model))
-
-    print("\n" + "=" * 20, end='')
-    print(pretty_format_meta(next(iter(reg.models))))
+        print("=" * 20, end='')
 
 
 if __name__ == '__main__':

testing_tools/real_apis/openlibrary.py

@@ -50,7 +50,7 @@ def main():
 
     print("\n" + "=" * 20, end='')
     for model in reg.models:
-        model.update_base_name()
+        model.generate_name()
     for model in reg.models:
         print(pretty_format_meta(model))
         print("\n" + "=" * 20, end='')

testing_tools/real_apis/pathofexile.py

@@ -38,7 +38,7 @@ def main():
 
     print("\n" + "=" * 20, end='')
     for model in reg.models:
-        model.update_base_name()
+        model.generate_name()
     print(pretty_format_meta(next(iter(reg.models))))