squash

Author: mosheduminer

.gitignore

@@ -123,3 +123,7 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+
+
+.vscode
+.idea

README.md

@@ -4,7 +4,7 @@
 
 This is currently a work in progress.
 
-The python client will support both sync and async programs.
+The python client supports both sync and async programs.
 
 The api docs can be built with the following:
 ```bash

pysirix/__init__.py

@@ -1,6 +1,7 @@
 from .client import SirixClient
 from .database import Database
 from .resource import Resource
+from .constants import Insert
 
 
 def Sirix(

pysirix/asynchronous/rest.py

@@ -131,6 +131,7 @@ async def async_update_resource(
         headers={
             "Authorization": f"Bearer {self._auth_data.access_token}",
             "Content-Type": data_type,
+            "ETag": etag,
         },
         ssl=False if self._allow_self_signed else True,
         data=data,

pysirix/client.py

@@ -1,5 +1,4 @@
-from typing import Tuple, Dict, List, Union
-import asyncio
+from typing import Dict, List, Union
 
 from requests import Session
 from aiohttp import ClientSession
@@ -54,6 +53,7 @@ def __init__(
         else:
             self._session = Session()
             if allow_self_signed:
+                self._allow_self_signed = allow_self_signed
                 self._session.verify = False
         self._auth = Auth(self._auth_data, self._instance_data, self._session, self._asynchronous, allow_self_signed)
 
@@ -73,15 +73,7 @@ async def _async_init(self):
         await self._auth.authenticate()
         await self.get_info()
 
-    def __getitem__(self, key: Union[Tuple[str], str]):
-        """
-        Returns a database instance. See :meth:`_get_database` for further information
-        """
-        if type(key) == tuple:
-            return self._get_database(*key)
-        return self._get_database(key)
-
-    def _get_database(self, database_name: str, database_type: str = None):
+    def database(self, database_name: str, database_type: str = None):
         """Returns a database instance
 
         If a database with the given name and type does not exist,
@@ -95,10 +87,6 @@ def _get_database(self, database_name: str, database_type: str = None):
 
         :param database_name: the name of the database to access
         :param database_type: the type of the database to access
-
-        You shouldn't use this method directly, rather, you should use index access, as follows:
-            >>> sirix = Sirix(*params)
-            >>> sirix[(database_name, database_type)]
         """
         db = Database(database_name, database_type, parent=self)
         db._init()

pysirix/database.py

@@ -37,52 +37,41 @@ def _init(self):
         database_list = [
             db
             for db in self._instance_data.database_info
-            if db["name"] == database_name
+            if db["name"] == self.database_name
         ]
         if len(database_list) != 0:
             self.database_type: str = database_list[0]["type"]
         elif self.database_type:
             self.database_type: str = self.database_type.lower()
-            self._create()
+            if self._asynchronous:
+                return handle_async(
+                    async_create_database, self, self.database_name, self.database_type
+                )
+            else:
+                return create_database(self, self.database_name, self.database_type)
         else:
             raise Exception(
                 "No database type specified, and database does not already exist"
             )
 
-    def _create(self):
-        """Creates the database. Should be called if the database does not yet exist"""
-        if self._asynchronous:
-            return handle_async(
-                async_create_database, self, self.database_name, self.database_type
-            )
-        else:
-            return create_database(self, self.database_type, self.database_type)
-
-    def __getitem__(self, key: str):
-        """
-        Returns a resource instance. See :meth:`_get_resource` for further information
-        """
-        return self._get_resource(key)
-
-    def _get_resource(self, resource_name: str, data: Union[str, ET.Element, Dict] = None):
+    def resource(self, resource_name: str, data: Union[str, ET.Element, Dict] = None):
         """Returns a resource instance
 
         If a resource with the given name and type does not exist,
         it is created.
 
         If the resource does not yet exist, it is created
 
-        :param database_name: the name of the database to access
-        :param database_type: the type of the database to access
         :param resource_name: the name of the resource to aceess
         :param data: data to initialize resource with if it does
                 yet exist
-
-        You shouldn't use this method directly, rather, you should use index access, as follows:
-            >>> sirix = Sirix(params)
-            >>> sirix[(database_name, database_type)]
         """
-        return Resource(resource_name, parent=self)
+        resource = Resource(resource_name, parent=self)
+        if self._asynchronous:
+            return handle_async(resource._async_init(), data)
+        else:
+            resource._init(data)
+        return resource
 
     def delete(self) -> bool:
         if self._asynchronous:

pysirix/resource.py

@@ -29,40 +29,49 @@ def __init__(self, resource_name: str, parent):
         self._auth_data: AuthData = parent._auth_data
         self._asynchronous = parent._asynchronous
 
-        self.database_name = database_name
-        self.database_type = database_type
+        self.database_name = parent.database_name
+        self.database_type = parent.database_type
         self.resource_name = resource_name
 
         self._allow_self_signed = parent._allow_self_signed
 
-    def _create(self, data: str):
-        """Creates the resource. Should be called if the resource does not yet exist
-        
+    def _init(self, data: Union[str, Dict, ET.Element, None]):
+        """
         :param data: the data to initialize the resource with
-                """
-        if self._asynchronous:
-            return handle_async(
-                async_create_resource,
-                self,
-                self.database_name,
-                self.database_type,
-                self.resource_name,
-                data=data,
-            )
-        else:
-            return create_resource(
-                self, self.database_type, self.database_type, self.resource_name
-            )
+        """
+        database_info = next(
+            (db
+            for db in self._instance_data.database_info
+            if db["name"] == self.database_name)
+        )
+        if self.resource_name not in database_info.get("resources"):
+            if not isinstance(data, str):
+                data = (
+                    json.dumps(data)
+                    if self.database_type == "json"
+                    else ET.tostring(data)
+                )
+            return create_resource(self, data)
+
+    def _async_init(self, data: Union[str, Dict, ET.Element]):
+        database_info = [
+            db
+            for db in self._instance_data.database_info
+            if db["name"] == self.database_name
+        ][0]
+        if self.resource_name not in database_info.get("resources"):
+            return handle_async(async_create_resource, self, data,)
 
     def read(
+        self,
         node_id: Union[int, None],
         revision: Union[Revision, Tuple[Revision, Revision], None] = None,
         max_level: Union[int, None] = None,
     ):
         if self._asynchronous:
-            return handle_async(async_read_resource, revision, node_id, max_level)
+            return handle_async(async_read_resource, self, revision, node_id, max_level)
         else:
-            return read_resource(revision, node_id, max_level)
+            return read_resource(self, revision, node_id, max_level)
 
     def update(
         self,
@@ -84,14 +93,19 @@ def update(
         )
         if (
             self.resource_name
-            not in self._instance_data.database_info[self.database_name]
+            not in next(
+                db
+                for db in self._instance_data.database_info
+                if db["name"] == self.database_name
+            )["resources"]
         ):
             return self._create(data)
         else:
+            print(insert.value)
             if self._asynchronous:
                 return async_update_resource(self, nodeId, data, insert)
             else:
-                return update_resource(self, nodeId, data, insert)
+                return update_resource(self, nodeId, data, insert.value)
 
     def delete(self, nodeId: Union[int, None]) -> bool:
         if self._asynchronous:

pysirix/sync/rest.py

@@ -115,7 +115,10 @@ def update_resource(self, node_id: int, data: str, insert: str) -> bool:
     response = self._session.head(
         f"{self._instance_data.sirix_uri}/{self.database_name}/{self.resource_name}",
         params=params,
-        headers={"Authorization": f"Bearer {self._auth_data.access_token}"},
+        headers={
+            "Authorization": f"Bearer {self._auth_data.access_token}",
+            "Accept": data_type,
+        },
     )
     etag = response.headers.get("ETag")
     # prepare to update
@@ -127,10 +130,12 @@ def update_resource(self, node_id: int, data: str, insert: str) -> bool:
         headers={
             "Authorization": f"Bearer {self._auth_data.access_token}",
             "Content-Type": data_type,
+            "ETag": etag,
         },
         data=data,
     )
-    if response.status_code == 201:
+    print(response)
+    if response.status_code == 200:
         return True
     return False