Merge pull request #296 from specklesystems/gergo/abstract_transport_no_pydantic

fix(AbstractTransport-and-subclasses): abstract transport and its subclasses should not be pydantic models

Author: gjedlicska

src/specklepy/transports/abstract_transport.py

@@ -1,17 +1,12 @@
 from abc import ABC, abstractmethod
 from typing import Dict, List, Optional
 
-from pydantic import BaseModel
-from pydantic.config import Extra
-
-
-class AbstractTransport(ABC, BaseModel):
-    _name: str = "Abstract"
-    model_config = {'extra': 'allow', 'arbitrary_types_allowed': True}
 
+class AbstractTransport(ABC):
     @property
+    @abstractmethod
     def name(self):
-        return type(self)._name
+        pass
 
     @abstractmethod
     def begin_write(self) -> None:

src/specklepy/transports/memory.py

@@ -4,14 +4,15 @@
 
 
 class MemoryTransport(AbstractTransport):
-    _name: str = "Memory"
-    objects: dict = {}
-    saved_object_count: int = 0
-
-    def __init__(self, name=None, **data: Any) -> None:
-        super().__init__(**data)
-        if name:
-            self._name = name
+    def __init__(self, name="Memory") -> None:
+        super().__init__()
+        self._name = name
+        self.objects = {}
+        self.saved_object_count = 0
+
+    @property
+    def name(self) -> str:
+        return self._name
 
     def __repr__(self) -> str:
         return f"MemoryTransport(objects: {len(self.objects)})"

src/specklepy/transports/server/server.py

@@ -45,29 +45,25 @@ class ServerTransport(AbstractTransport):
     ```
     """
 
-    _name = "RemoteTransport"
-    url: Optional[str] = None
-    stream_id: Optional[str] = None
-    account: Optional[Account] = None
-    saved_obj_count: int = 0
-    session: Optional[requests.Session] = None
-
     def __init__(
         self,
         stream_id: str,
         client: Optional[SpeckleClient] = None,
         account: Optional[Account] = None,
         token: Optional[str] = None,
         url: Optional[str] = None,
-        **data: Any,
+        name: str = "RemoteTransport",
     ) -> None:
-        super().__init__(**data)
+        super().__init__()
         if client is None and account is None and token is None and url is None:
             raise SpeckleException(
                 "You must provide either a client or a token and url to construct a"
                 " ServerTransport."
             )
 
+        self._name = name
+        self.account = None
+        self.saved_obj_count = 0
         if account:
             self.account = account
             url = account.serverInfo.url
@@ -97,6 +93,10 @@ def __init__(
             {"Authorization": f"Bearer {self.account.token}", "Accept": "text/plain"}
         )
 
+    @property
+    def name(self) -> str:
+        return self._name
+
     def begin_write(self) -> None:
         self.saved_obj_count = 0
 

src/specklepy/transports/sqlite.py

@@ -9,31 +9,22 @@
 
 
 class SQLiteTransport(AbstractTransport):
-    _name = "SQLite"
-    _base_path: Optional[str] = None
-    _root_path: Optional[str] = None
-    __connection: Optional[sqlite3.Connection] = None
-    app_name: str = ""
-    scope: str = ""
-    saved_obj_count: int = 0
-    max_size: Optional[int] = None
-    _current_batch: Optional[List[Tuple[str, str]]] = None
-    _current_batch_size: Optional[int] = None
-
     def __init__(
         self,
         base_path: Optional[str] = None,
         app_name: Optional[str] = None,
         scope: Optional[str] = None,
         max_batch_size_mb: float = 10.0,
-        **data: Any,
+        name: str = "SQLite",
     ) -> None:
-        super().__init__(**data)
+        super().__init__()
+        self._name = name
         self.app_name = app_name or "Speckle"
         self.scope = scope or "Objects"
         self._base_path = base_path or self.get_base_path(self.app_name)
         self.max_size = int(max_batch_size_mb * 1000 * 1000)
-        self._current_batch = []
+        self.saved_obj_count = 0
+        self._current_batch: List[Tuple[str, str]] = []
         self._current_batch_size = 0
 
         try:
@@ -54,24 +45,12 @@ def __init__(
     def __repr__(self) -> str:
         return f"SQLiteTransport(app: '{self.app_name}', scope: '{self.scope}')"
 
+    @property
+    def name(self) -> str:
+        return self._name
+
     @staticmethod
     def get_base_path(app_name):
-        # # from appdirs https://github.com/ActiveState/appdirs/blob/master/appdirs.py
-        # # default mac path is not the one we use (we use unix path), so using special case for this
-        # system = sys.platform
-        # if system.startswith("java"):
-        #     import platform
-
-        #     os_name = platform.java_ver()[3][0]
-        #     if os_name.startswith("Mac"):
-        #         system = "darwin"
-
-        # if system != "darwin":
-        #     return user_data_dir(appname=app_name, appauthor=False, roaming=True)
-
-        # path = os.path.expanduser("~/.config/")
-        # return os.path.join(path, app_name)
-
         return str(
             speckle_path_provider.user_application_data_path().joinpath(app_name)
         )