Generator improvements

Author: [email protected]

generator/__init__.py

@@ -0,0 +1,10 @@
+import os
+from configparser import ConfigParser
+
+
+def load_settings():
+    cp = ConfigParser()
+    root_dir = os.path.dirname(os.path.abspath(__file__))
+    config_file = os.path.join(root_dir, 'settings.cfg')
+    cp.read(config_file)
+    return cp

generator/builders/method_builder.py

@@ -0,0 +1,5 @@
+import ast
+
+
+class MethodBuilder(ast.NodeTransformer):
+    pass

generator/builders/template_context.py

@@ -1,5 +1,8 @@
 class TemplateContext:
     def __init__(self, template_path):
+        """
+        :type template_path: str
+        """
         self._template_path = template_path
 
     def build(self, schema):

generator/builders/type_builder.py

@@ -1,47 +1,86 @@
 import ast
 import os
-
+from os.path import abspath
+from pydoc import locate
 
 import astunparse
 
 
 class TypeBuilder(ast.NodeTransformer):
 
-    def __init__(self, options):
-        self._schema = None
+    def __init__(self, type_schema, options):
+        """
+        :type type_schema: office365.runtime.odata.odata_type.ODataType
+        :type options: dict
+        """
+        self._schema = type_schema
         self._options = options
+        self._type_info = None
+        self._source_tree = None
+        self._status = None
 
     def generic_visit(self, node):
         if isinstance(node, ast.ClassDef):
-            node.name = self._schema["name"].title()
+            node.name = self._schema.name.title()
         ast.NodeVisitor.generic_visit(self, node)
 
-    def build(self, schema):
-        result = dict(status=None, output_file=None, source_tree=None)
-        if schema['state'] == 'attached':
-            result["output_file"] = schema['file']
-            with open(schema['file']) as f:
-                result["source_tree"] = ast.parse(f.read())
-            result["status"] = "updated"
+    def build(self):
+        if self.state == 'attached':
+            with open(self.file) as f:
+                self._source_tree = ast.parse(f.read())
+            self._status = "updated"
         else:
-            template_file = self._resolve_template_file(schema['baseType'])
-            result["output_file"] = os.path.join(self._options['outputPath'], schema["name"] + ".py")
+            template_file = self._resolve_template_file(self._schema.baseType)
             with open(template_file) as f:
-                result["source_tree"] = ast.parse(f.read())
-            result["status"] = "created"
-        self._schema = schema
-        self.visit(result["source_tree"])
-        return result
-
-    def save(self, result):
-        code = astunparse.unparse(result["source_tree"])
-        with open(result["output_file"], 'w') as f:
+                self._source_tree = ast.parse(f.read())
+            self._status = "created"
+        self.visit(self._source_tree)
+        return self
+
+    def save(self):
+        code = astunparse.unparse(self._source_tree)
+        with open(self.file, 'w') as f:
             f.write(code)
 
     def _resolve_template_file(self, type_name):
         file_mapping = {
             "ComplexType": "complex_type.py",
             "EntityType": "entity_type.py"
         }
-        path = os.path.join(self._options['templatePath'], file_mapping[type_name])
+        path = abspath(os.path.join(self._options['templatePath'], file_mapping[type_name]))
         return path
+
+    def _resolve_type(self, type_name):
+        """
+        :type type_name: str
+        """
+        type_info = {}
+        namespaces = ['directory', 'onedrive', 'mail', 'teams']
+        types = [locate("office365.{0}.{1}".format(ns, type_name)) for ns in namespaces]
+        found_modules = [t for t in types if t is not None]
+        if any(found_modules):
+            type_info['state'] = 'attached'
+            type_info['file'] = found_modules[0].__file__
+        else:
+            type_info['state'] = 'detached'
+            type_info['file'] = abspath(os.path.join(self._options['outputPath'], type_name + ".py"))
+        return type_info
+
+    def _ensure_type_info(self):
+        if self._type_info is None:
+            self._type_info = self._resolve_type(self._schema.name)
+        return self._type_info
+
+    @property
+    def state(self):
+        self._ensure_type_info()
+        return self._type_info['state']
+
+    @property
+    def file(self):
+        self._ensure_type_info()
+        return self._type_info['file']
+
+    @property
+    def status(self):
+        return self._status

generator/generate.py

@@ -1,41 +1,36 @@
+from generator import load_settings
 from generator.builders.type_builder import TypeBuilder
 
 from office365.runtime.odata.odata_v3_reader import ODataV3Reader
 from office365.runtime.odata.odata_v4_reader import ODataV4Reader
 
 
 def generate_files(model, options):
+    """
+    :type model: office365.runtime.odata.odata_model.ODataModel
+    :type options: ConfigParser
+    """
     for name in model.types:
         type_schema = model.types[name]
-        builder = TypeBuilder(options)
-        result = builder.build(type_schema)
-        if result["status"] == "created":
-            builder.save(result)
-
-
-def generate_sharepoint_model():
-    generator_options = {
-        'namespace': 'office365.sharepoint',
-        'metadataPath': './metadata/SharePoint.xml',
-        'outputPath': '/office365/sharepoint',
-        'templatePath': '/generator/templates',
-    }
-    reader = ODataV3Reader(generator_options)
+        builder = TypeBuilder(type_schema, options)
+        builder.build()
+        if builder.status == "created":
+            builder.save()
+
+
+def generate_sharepoint_model(settings):
+    reader = ODataV3Reader(settings.get('sharepoint', 'metadataPath'))
     model = reader.generate_model()
-    generate_files(model, generator_options)
+    generate_files(model, settings)
 
 
-def generate_graph_model():
-    options = {
-        'namespace': 'office365',
-        'metadataPath': './metadata/MicrosoftGraph.xml',
-        'outputPath': '../office365',
-        'templatePath': '../generator/templates',
-    }
-    reader = ODataV4Reader(options)
+def generate_graph_model(settings):
+    reader = ODataV4Reader(settings.get('microsoftgraph', 'metadataPath'))
     model = reader.generate_model()
-    generate_files(model, options)
+    generate_files(model, settings)
 
 
 if __name__ == '__main__':
-    generate_graph_model()
+    generator_settings = load_settings()
+    # generate_graph_model(settings)
+    generate_sharepoint_model(generator_settings)

generator/requirements.txt

@@ -0,0 +1 @@
+astunparse==1.6.3

generator/settings.cfg

@@ -0,0 +1,12 @@
+[microsoftgraph]
+namespace = office365
+metadataPath = ./metadata/MicrosoftGraph.xml
+outputPath = ../office365
+templatePath: ../generator/templates
+
+
+[sharepoint]
+namespace =  'office365.sharepoint
+metadataPath = ./metadata/SharePoint.xml
+outputPath = ../office365/sharepoint
+templatePath = ./templates

office365/actions/search_query.py

@@ -1,6 +1,21 @@
+from office365.runtime.client_result import ClientResult
+from office365.runtime.http.http_method import HttpMethod
 from office365.runtime.queries.service_operation_query import ServiceOperationQuery
 
 
-class SearchQuery(ServiceOperationQuery):
-    def __init__(self, entity_type, query_text, return_type):
-        super(SearchQuery, self).__init__(entity_type, "search", {"q": query_text}, None, None, return_type)
+def create_search_query(drive_item, query_text):
+    """
+
+    :param office365.onedrive.driveItem.DriveItem drive_item:
+    :param str query_text:
+    """
+    result = ClientResult(drive_item.context)
+    qry = ServiceOperationQuery(drive_item, "search", {"q": query_text}, None, None, result)
+
+    def _construct_query(request):
+        """
+        :type request: office365.runtime.http.request_options.RequestOptions
+        """
+        request.method = HttpMethod.Get
+    drive_item.context.before_execute(_construct_query)
+    return qry

office365/directory/user.py

@@ -106,6 +106,9 @@ def get_calendar_view(self, start_dt, end_dt):
         self.context.add_query(qry)
 
         def _construct_request(request):
+            """
+            :type request: office365.runtime.http.request_options.RequestOptions
+            """
             request.method = HttpMethod.Get
             request.url += "?startDateTime={0}&endDateTime={1}".format(start_dt.isoformat(), end_dt.isoformat())
 

office365/entity.py

@@ -23,7 +23,7 @@ def delete_object(self):
     @property
     def context(self):
         """
-        :rtype: office365.graph.graph_client.GraphClient
+        :rtype: office365.graph_client.GraphClient
         """
         return self._context