Custom exception class, typo fixes.

Author: rawandahmad698

Diff for: supabase/client.py

@@ -11,14 +11,21 @@
 from .lib.storage_client import SupabaseStorageClient
 
 
+# Create an exception class when user does not provide a valid url or key.
+class SupabaseException(Exception):
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(self.message)
+
+
 class Client:
     """Supabase client class."""
 
     def __init__(
-        self,
-        supabase_url: str,
-        supabase_key: str,
-        options: ClientOptions = ClientOptions(),
+            self,
+            supabase_url: str,
+            supabase_key: str,
+            options: ClientOptions = ClientOptions(),
     ):
         """Instantiate the client.
 
@@ -34,9 +41,18 @@ def __init__(
         """
 
         if not supabase_url:
-            raise Exception("supabase_url is required")
+            raise SupabaseException("supabase_url is required")
         if not supabase_key:
-            raise Exception("supabase_key is required")
+            raise SupabaseException("supabase_key is required")
+
+        # Check if the url and key are valid
+        if not re.match(r"^(https?)://.+", supabase_url):
+            raise SupabaseException("Invalid URL")
+
+        # Check if the key is a valid JWT
+        if not re.match(r"^[A-Za-z0-9-_=]+\.[A-Za-z0-9-_=]+\.?[A-Za-z0-9-_.+/=]*$", supabase_key):
+            raise SupabaseException("Invalid API key")
+
         self.supabase_url = supabase_url
         self.supabase_key = supabase_key
         options.headers.update(self._get_auth_headers())
@@ -58,10 +74,9 @@ def __init__(
         # Instantiate clients.
         self.auth = self._init_supabase_auth_client(
             auth_url=self.auth_url,
-            supabase_key=self.supabase_key,
             client_options=options,
         )
-        # TODO(fedden): Bring up to parity with JS client.
+        # TODO: Bring up to parity with JS client.
         # self.realtime: SupabaseRealtimeClient = self._init_realtime_client(
         #     realtime_url=self.realtime_url,
         #     supabase_key=self.supabase_key,
@@ -85,7 +100,7 @@ def table(self, table_name: str) -> SyncRequestBuilder:
         """Perform a table operation.
 
         Note that the supabase client uses the `from` method, but in Python,
-        this is a reserved keyword so we have elected to use the name `table`.
+        this is a reserved keyword, so we have elected to use the name `table`.
         Alternatively you can use the `.from_()` method.
         """
         return self.from_(table_name)
@@ -153,9 +168,8 @@ def rpc(self, fn: str, params: Dict[Any, Any]) -> SyncFilterRequestBuilder:
 
     @staticmethod
     def _init_supabase_auth_client(
-        auth_url: str,
-        supabase_key: str,
-        client_options: ClientOptions,
+            auth_url: str,
+            client_options: ClientOptions,
     ) -> SupabaseAuthClient:
         """Creates a wrapped instance of the GoTrue Client."""
         return SupabaseAuthClient(
@@ -168,11 +182,11 @@ def _init_supabase_auth_client(
 
     @staticmethod
     def _init_postgrest_client(
-        rest_url: str,
-        supabase_key: str,
-        headers: Dict[str, str],
-        schema: str,
-        timeout: Union[int, float, Timeout] = DEFAULT_POSTGREST_CLIENT_TIMEOUT,
+            rest_url: str,
+            supabase_key: str,
+            headers: Dict[str, str],
+            schema: str,
+            timeout: Union[int, float, Timeout] = DEFAULT_POSTGREST_CLIENT_TIMEOUT,
     ) -> SyncPostgrestClient:
         """Private helper for creating an instance of the Postgrest client."""
         client = SyncPostgrestClient(
@@ -191,9 +205,9 @@ def _get_auth_headers(self) -> Dict[str, str]:
 
 
 def create_client(
-    supabase_url: str,
-    supabase_key: str,
-    options: ClientOptions = ClientOptions(),
+        supabase_url: str,
+        supabase_key: str,
+        options: ClientOptions = ClientOptions(),
 ) -> Client:
     """Create client function to instantiate supabase client like JS runtime.
 

Diff for: supabase/lib/auth_client.py

@@ -25,7 +25,7 @@ def __init__(
         api: Optional[SyncGoTrueAPI] = None,
         replace_default_headers: bool = False,
     ):
-        """Instanciate SupabaseAuthClient instance."""
+        """Instantiate SupabaseAuthClient instance."""
         SyncGoTrueClient.__init__(
             self,
             url=url,

Diff for: supabase/lib/client_options.py

@@ -1,65 +1,52 @@
-from dataclasses import dataclass, field
-from typing import Any, Callable, Dict, Optional, Union
+from typing import Any, Callable
 
-from gotrue import SyncMemoryStorage, SyncSupportedStorage
-from httpx import Timeout
-from postgrest.constants import DEFAULT_POSTGREST_CLIENT_TIMEOUT
+from realtime.connection import Socket
+from realtime.transformers import convert_change_data
 
-from supabase import __version__
 
-DEFAULT_HEADERS = {"X-Client-Info": f"supabase-py/{__version__}"}
-
-
-@dataclass
-class ClientOptions:
-    schema: str = "public"
-    """
-    The Postgres schema which your tables belong to.
-    Must be on the list of exposed schemas in Supabase. Defaults to 'public'.
-    """
-
-    headers: Dict[str, str] = field(default_factory=DEFAULT_HEADERS.copy)
-    """Optional headers for initializing the client."""
-
-    auto_refresh_token: bool = True
-    """Automatically refreshes the token for logged in users."""
-
-    persist_session: bool = True
-    """Whether to persist a logged in session to storage."""
-
-    local_storage: SyncSupportedStorage = field(default_factory=SyncMemoryStorage)
-    """A storage provider. Used to store the logged in session."""
-
-    realtime: Optional[Dict[str, Any]] = None
-    """Options passed to the realtime-py instance"""
-
-    fetch: Optional[Callable] = None
-    """A custom `fetch` implementation."""
-
-    timeout: Union[int, float, Timeout] = DEFAULT_POSTGREST_CLIENT_TIMEOUT
-    """Timeout passed to the SyncPostgrestClient instance."""
-
-    def replace(
-        self,
-        schema: Optional[str] = None,
-        headers: Optional[Dict[str, str]] = None,
-        auto_refresh_token: Optional[bool] = None,
-        persist_session: Optional[bool] = None,
-        local_storage: Optional[SyncSupportedStorage] = None,
-        realtime: Optional[Dict[str, Any]] = None,
-        fetch: Optional[Callable] = None,
-        timeout: Union[int, float, Timeout] = DEFAULT_POSTGREST_CLIENT_TIMEOUT,
-    ) -> "ClientOptions":
-        """Create a new SupabaseClientOptions with changes"""
-        client_options = ClientOptions()
-        client_options.schema = schema or self.schema
-        client_options.headers = headers or self.headers
-        client_options.auto_refresh_token = (
-            auto_refresh_token or self.auto_refresh_token
+class SupabaseRealtimeClient:
+    def __init__(self, socket: Socket, schema: str, table_name: str):
+        topic = (
+            f"realtime:{schema}"
+            if table_name == "*"
+            else f"realtime:{schema}:{table_name}"
+        )
+        self.subscription = socket.set_channel(topic)
+
+    @staticmethod
+    def get_payload_records(payload: Any):
+        records: dict = {"new": {}, "old": {}}
+        if payload.type in ["INSERT", "UPDATE"]:
+            records["new"] = payload.record
+            convert_change_data(payload.columns, payload.record)
+        if payload.type in ["UPDATE", "DELETE"]:
+            records["old"] = payload.record
+            convert_change_data(payload.columns, payload.old_record)
+        return records
+
+    def on(self, event, callback: Callable[..., Any]):
+        def cb(payload):
+            enriched_payload = {
+                "schema": payload.schema,
+                "table": payload.table,
+                "commit_timestamp": payload.commit_timestamp,
+                "event_type": payload.type,
+                "new": {},
+                "old": {},
+            }
+            enriched_payload = {**enriched_payload, **self.get_payload_records(payload)}
+            callback(enriched_payload)
+
+        self.subscription.join().on(event, cb)
+        return self
+
+    def subscribe(self, callback: Callable[..., Any]):
+        # TODO: Handle state change callbacks for error and close
+        self.subscription.join().on("ok", callback("SUBSCRIBED"))
+        self.subscription.join().on(
+            "error", lambda x: callback("SUBSCRIPTION_ERROR", x)
+        )
+        self.subscription.join().on(
+            "timeout", lambda: callback("RETRYING_AFTER_TIMEOUT")
         )
-        client_options.persist_session = persist_session or self.persist_session
-        client_options.local_storage = local_storage or self.local_storage
-        client_options.realtime = realtime or self.realtime
-        client_options.fetch = fetch or self.fetch
-        client_options.timeout = timeout or self.timeout
-        return client_options
+        return self.subscription

Diff for: supabase/lib/realtime_client.py

@@ -13,7 +13,8 @@ def __init__(self, socket: Socket, schema: str, table_name: str):
         )
         self.subscription = socket.set_channel(topic)
 
-    def get_payload_records(self, payload: Any):
+    @staticmethod
+    def get_payload_records(payload: Any):
         records: dict = {"new": {}, "old": {}}
         if payload.type in ["INSERT", "UPDATE"]:
             records["new"] = payload.record