Sqlalchemy compositional

.github/workflows/test.yml

@@ -72,8 +72,7 @@ jobs:
 
       - name: Initialize mypy
         run: |
-          mypy . > /dev/null || true
-          mypy --install-types --non-interactive
+          mypy --install-types --non-interactive . || true
 
       - name: Run tests
         run: |

docs/api.rst

@@ -15,30 +15,27 @@ Get a driver instance
 
 .. autofunction:: terracotta.get_driver
 
-SQLite driver
--------------
+TerracottaDriver
+----------------
 
-.. autoclass:: terracotta.drivers.sqlite.SQLiteDriver
+.. autoclass:: terracotta.drivers.TerracottaDriver
    :members:
-   :undoc-members:
-   :special-members: __init__
-   :inherited-members:
 
-Remote SQLite driver
---------------------
 
-.. autoclass:: terracotta.drivers.sqlite_remote.RemoteSQLiteDriver
-   :members:
-   :undoc-members:
-   :special-members: __init__
-   :inherited-members:
-   :exclude-members: delete, insert, create
+Supported metadata stores
+-------------------------
 
-MySQL driver
-------------
+SQLite metadata store
++++++++++++++++++++++
 
-.. autoclass:: terracotta.drivers.mysql.MySQLDriver
-   :members:
-   :undoc-members:
-   :special-members: __init__
-   :inherited-members:
+.. autoclass:: terracotta.drivers.sqlite_meta_store.SQLiteMetaStore
+
+Remote SQLite metadata store
+++++++++++++++++++++++++++++
+
+.. autoclass:: terracotta.drivers.sqlite_remote_meta_store.RemoteSQLiteMetaStore
+
+MySQL metadata store
+++++++++++++++++++++
+
+.. autoclass:: terracotta.drivers.mysql_meta_store.MySQLMetaStore

setup.py

@@ -78,7 +78,7 @@
     ],
     extras_require={
         'test': [
-            'pytest',
+            'pytest<7.0',
             'pytest-cov',
             'pytest-mypy',
             'pytest-flake8',

terracotta/drivers/__init__.py

@@ -8,29 +8,31 @@
 import urllib.parse as urlparse
 from pathlib import Path
 
-from terracotta.drivers.base import Driver
+from terracotta.drivers.base_classes import MetaStore
+from terracotta.drivers.terracotta_driver import TerracottaDriver
+from terracotta.drivers.geotiff_raster_store import GeoTiffRasterStore
 
 URLOrPathType = Union[str, Path]
 
 
-def load_driver(provider: str) -> Type[Driver]:
+def load_driver(provider: str) -> Type[MetaStore]:
     if provider == 'sqlite-remote':
-        from terracotta.drivers.sqlite_remote import RemoteSQLiteDriver
-        return RemoteSQLiteDriver
+        from terracotta.drivers.sqlite_remote_meta_store import RemoteSQLiteMetaStore
+        return RemoteSQLiteMetaStore
 
     if provider == 'mysql':
-        from terracotta.drivers.mysql import MySQLDriver
-        return MySQLDriver
+        from terracotta.drivers.mysql_meta_store import MySQLMetaStore
+        return MySQLMetaStore
 
     if provider == 'sqlite':
-        from terracotta.drivers.sqlite import SQLiteDriver
-        return SQLiteDriver
+        from terracotta.drivers.sqlite_meta_store import SQLiteMetaStore
+        return SQLiteMetaStore
 
     raise ValueError(f'Unknown database provider {provider}')
 
 
-def auto_detect_provider(url_or_path: Union[str, Path]) -> str:
-    parsed_path = urlparse.urlparse(str(url_or_path))
+def auto_detect_provider(url_or_path: str) -> str:
+    parsed_path = urlparse.urlparse(url_or_path)
 
     scheme = parsed_path.scheme
     if scheme == 's3':
@@ -42,10 +44,10 @@ def auto_detect_provider(url_or_path: Union[str, Path]) -> str:
     return 'sqlite'
 
 
-_DRIVER_CACHE: Dict[Tuple[URLOrPathType, str, int], Driver] = {}
+_DRIVER_CACHE: Dict[Tuple[URLOrPathType, str, int], TerracottaDriver] = {}
 
 
-def get_driver(url_or_path: URLOrPathType, provider: str = None) -> Driver:
+def get_driver(url_or_path: URLOrPathType, provider: str = None) -> TerracottaDriver:
     """Retrieve Terracotta driver instance for the given path.
 
     This function always returns the same instance for identical inputs.
@@ -66,25 +68,37 @@ def get_driver(url_or_path: URLOrPathType, provider: str = None) -> Driver:
 
         >>> import terracotta as tc
         >>> tc.get_driver('tc.sqlite')
-        SQLiteDriver('/home/terracotta/tc.sqlite')
+        TerracottaDriver(
+            meta_store=SQLiteDriver('/home/terracotta/tc.sqlite'),
+            raster_store=GeoTiffRasterStore()
+        )
         >>> tc.get_driver('mysql://root@localhost/tc')
-        MySQLDriver('mysql://root@localhost:3306/tc')
+        TerracottaDriver(
+            meta_store=MySQLDriver('mysql+pymysql://localhost:3306/tc'),
+            raster_store=GeoTiffRasterStore()
+        )
         >>> # pass provider if path is given in a non-standard way
         >>> tc.get_driver('root@localhost/tc', provider='mysql')
-        MySQLDriver('mysql://root@localhost:3306/tc')
+        TerracottaDriver(
+            meta_store=MySQLDriver('mysql+pymysql://localhost:3306/tc'),
+            raster_store=GeoTiffRasterStore()
+        )
 
     """
+    url_or_path = str(url_or_path)
+
     if provider is None:  # try and auto-detect
         provider = auto_detect_provider(url_or_path)
 
-    if isinstance(url_or_path, Path):
-        url_or_path = str(url_or_path)
-
     DriverClass = load_driver(provider)
     normalized_path = DriverClass._normalize_path(url_or_path)
     cache_key = (normalized_path, provider, os.getpid())
 
     if cache_key not in _DRIVER_CACHE:
-        _DRIVER_CACHE[cache_key] = DriverClass(url_or_path)
+        driver = TerracottaDriver(
+            meta_store=DriverClass(url_or_path),
+            raster_store=GeoTiffRasterStore()
+        )
+        _DRIVER_CACHE[cache_key] = driver
 
     return _DRIVER_CACHE[cache_key]