Generator improvements

Author: [email protected]

Diff for: 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

Diff for: generator/builders/method_builder.py

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

Diff for: 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):

Diff for: 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

Diff for: 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)

Diff for: generator/requirements.txt

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

Diff for: 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

Diff for: 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

Diff for: 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())
 

Diff for: 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
 

Diff for: office365/entity_collection.py

@@ -17,17 +17,17 @@ def __getitem__(self, key):
             return super(EntityCollection, self).__getitem__(key)
         return self._item_type(self.context, ResourcePath(key, self.resource_path))
 
-    def add_from_json(self, params):
+    def add_from_json(self, json):
         """Creates a Entity resource from JSON
 
-        :type params: dict
+        :type json: dict
         :rtype: office365.entity.Entity
         """
-        entity_object = self._item_type(self.context)
-        self.add_child(entity_object)
-        qry = CreateEntityQuery(self, params, entity_object)
+        entity = self._item_type(self.context)
+        self.add_child(entity)
+        qry = CreateEntityQuery(self, json, entity)
         self.context.add_query(qry)
-        return entity_object
+        return entity
 
     @property
     def context(self):

Diff for: office365/graph_client.py

@@ -1,5 +1,4 @@
 from office365.actions.download_content_query import DownloadContentQuery
-from office365.actions.search_query import SearchQuery
 from office365.actions.upload_content_query import UploadContentQuery
 from office365.directory.applicationCollection import ApplicationCollection
 from office365.directory.directory import Directory
@@ -81,8 +80,6 @@ def _build_specific_query(self, request):
             request.method = HttpMethod.Get
         elif isinstance(query, UploadContentQuery):
             request.method = HttpMethod.Put
-        elif isinstance(query, SearchQuery):
-            request.method = HttpMethod.Get
 
     def authenticate_request(self, request):
         """

Diff for: office365/onedrive/driveItem.py

@@ -1,4 +1,4 @@
-from office365.actions.search_query import SearchQuery
+from office365.actions.search_query import create_search_query
 from office365.base_item import BaseItem
 from office365.directory.permission import Permission
 from office365.directory.permission_collection import PermissionCollection
@@ -248,11 +248,12 @@ def search(self, query_text):
         """Search the hierarchy of items for items matching a query. You can search within a folder hierarchy,
         a whole drive, or files shared with the current user.
 
-        :type query_text: str"""
-        result = ClientResult(self.context)
-        qry = SearchQuery(self, query_text, result)
+        :type query_text: str
+        :rtype: ClientResult
+        """
+        qry = create_search_query(self, query_text)
         self.context.add_query(qry)
-        return result
+        return qry.return_type
 
     def invite(self, recipients, message, require_sign_in=True, send_invitation=True, roles=None):
         """Sends a sharing invitation for a driveItem. A sharing invitation provides permissions to the recipients

Diff for: office365/runtime/odata/odata_base_reader.py

@@ -0,0 +1,2 @@
+class ODataMethod(object):
+    pass

Diff for: office365/runtime/odata/odata_method.py

@@ -1,33 +1,15 @@
-from pydoc import locate
-
-
 class ODataModel(object):
     """OData model"""
     _types = {}
-    _namespaces = ['directory', 'onedrive', 'mail', 'teams']
 
     @property
     def types(self):
         return self._types
 
-    def resolve_type(self, schema):
-        type_alias = schema['name']
-        types = [locate("office365.{0}.{1}".format(ns, type_alias)) for ns in self._namespaces]
-        found_modules = [t for t in types if t is not None]
-        if any(found_modules):
-            schema['state'] = 'attached'
-            schema['file'] = found_modules[0].__file__
-        else:
-            schema['state'] = 'detached'
-            schema['file'] = ''
-        schema['properties'] = {}
-        self._types[type_alias] = schema
-
-    def resolve_property(self, type_schema, prop_schema):
-        alias = prop_schema['name']
-        if type_schema['state'] == 'detached':
-            prop_schema['state'] = 'detached'
-        else:
-            prop_schema['state'] = 'attached'
-        type_alias = type_schema['name']
-        self._types[type_alias]['properties'][alias] = prop_schema
+    def add_type(self, type_schema):
+        """
+        :type type_schema: office365.runtime.odata.odata_type.ODataType
+        :return:
+        """
+        type_alias = type_schema.name
+        self._types[type_alias] = type_schema

Diff for: office365/runtime/odata/odata_model.py

@@ -0,0 +1,2 @@
+class ODataParameter(object):
+    pass