cecil 0.0.16__tar.gz → 0.0.18__tar.gz

{cecil-0.0.16 → cecil-0.0.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecil
-Version: 0.0.16
+Version: 0.0.18
 Summary: Python SDK for Cecil Earth
 License-Expression: MIT
 License-File: LICENSE.txt

{cecil-0.0.16 → cecil-0.0.18}/src/cecil/client.py

@@ -1,45 +1,48 @@
 import os
+from typing import Dict, List
+
+import pandas as pd
 import requests
 import snowflake.connector
-
 from pydantic import BaseModel
 from requests import auth
-from typing import Dict, List
+from cryptography.hazmat.primitives import serialization
 
 from .errors import (
     Error,
     _handle_bad_request,
     _handle_not_found,
+    _handle_too_many_requests,
     _handle_unprocessable_entity,
 )
-
 from .models import (
     AOI,
     AOICreate,
     DataRequest,
     DataRequestCreate,
-    Transformation,
-    TransformationCreate,
+    OrganisationCreate,
     RecoverAPIKey,
     RecoverAPIKeyRequest,
     RotateAPIKey,
     RotateAPIKeyRequest,
-    SnowflakeCredentials,
+    SignUpRequest,
+    SignUpResponse,
+    SnowflakeUserCredentials,
+    Transformation,
+    TransformationCreate,
+    User,
+    UserCreate,
 )
-
 from .version import __version__
 
-# TODO: Documentation (Google style)
-# TODO: Add HTTP retries
-
 
 class Client:
-    def __init__(self, env=None):
+    def __init__(self, env: str = None) -> None:
         self._api_auth = None
         self._base_url = (
             "https://api.cecil.earth" if env is None else f"https://{env}.cecil.earth"
         )
-        self._snowflake_creds = None
+        self._snowflake_user_creds = None
 
     def create_aoi(self, name: str, geometry: Dict) -> AOI:
         # TODO: validate geometry
@@ -65,14 +68,13 @@ class Client:
         res = self._get(url=f"/v0/data-requests/{id}")
         return DataRequest(**res)
 
-    def list_data_requests(self):
+    def list_data_requests(self) -> List[DataRequest]:
         res = self._get(url="/v0/data-requests")
         return [DataRequest(**record) for record in res["records"]]
 
     def create_transformation(
         self, data_request_id: str, crs: str, spatial_resolution: float
     ) -> Transformation:
-        # TODO: check if data request is completed before creating transformation
         res = self._post(
             url="/v0/transformations",
             model=TransformationCreate(
@@ -91,15 +93,20 @@ class Client:
         res = self._get(url="/v0/transformations")
         return [Transformation(**record) for record in res["records"]]
 
-    def query(self, sql):
-        if self._snowflake_creds is None:
-            res = self._get(url="/v0/data-access-credentials")
-            self._snowflake_creds = SnowflakeCredentials(**res)
+    def query(self, sql: str) -> pd.DataFrame:
+        if self._snowflake_user_creds is None:
+            res = self._get(url="/v0/snowflake-user-credentials")
+            self._snowflake_user_creds = SnowflakeUserCredentials(**res)
+
+        private_key = serialization.load_pem_private_key(
+            self._snowflake_user_creds.private_key.get_secret_value().encode(),
+            password=None,
+        )
 
         with snowflake.connector.connect(
-            account=self._snowflake_creds.account.get_secret_value(),
-            user=self._snowflake_creds.user.get_secret_value(),
-            password=self._snowflake_creds.password.get_secret_value(),
+            account=self._snowflake_user_creds.account.get_secret_value(),
+            user=self._snowflake_user_creds.user.get_secret_value(),
+            private_key=private_key,
         ) as conn:
             df = conn.cursor().execute(sql).fetch_pandas_all()
             df.columns = [x.lower() for x in df.columns]
@@ -108,7 +115,7 @@ class Client:
 
     def recover_api_key(self, email: str) -> RecoverAPIKey:
         res = self._post(
-            url=f"/v0/recover-api-key",
+            url="/v0/api-key/recover",
             model=RecoverAPIKeyRequest(email=email),
             skip_auth=True,
         )
@@ -116,10 +123,43 @@ class Client:
         return RecoverAPIKey(**res)
 
     def rotate_api_key(self) -> RotateAPIKey:
-        res = self._post(url=f"/v0/rotate-api-key", model=RotateAPIKeyRequest())
+        res = self._post(url=f"/v0/api-key/rotate", model=RotateAPIKeyRequest())
 
         return RotateAPIKey(**res)
 
+    def sign_up(
+        self, organisation: Dict[str, str], user: Dict[str, str]
+    ) -> SignUpResponse:
+        res = self._post(
+            url="/v0/sign-up",
+            model=SignUpRequest(
+                organisation=OrganisationCreate(**organisation),
+                user=UserCreate(**user),
+            ),
+            skip_auth=True,
+        )
+
+        return SignUpResponse(**res)
+
+    def create_user(self, first_name: str, last_name: str, email: str) -> User:
+        res = self._post(
+            url="/v0/users",
+            model=UserCreate(
+                first_name=first_name,
+                last_name=last_name,
+                email=email,
+            ),
+        )
+        return User(**res)
+
+    def get_user(self, id: str) -> User:
+        res = self._get(url=f"/v0/users/{id}")
+        return User(**res)
+
+    def list_users(self) -> List[User]:
+        res = self._get(url="/v0/users")
+        return [User(**record) for record in res["records"]]
+
     def _request(self, method: str, url: str, skip_auth=False, **kwargs) -> Dict:
 
         if skip_auth is False:
@@ -141,7 +181,12 @@ class Client:
 
         except requests.exceptions.ConnectionError:
             raise Error("failed to connect to the Cecil Platform")
+
         except requests.exceptions.HTTPError as err:
+            message = f"Request failed with status code {err.response.status_code}"
+            if err.response.text != "":
+                message += f": {err.response.text}"
+
             match err.response.status_code:
                 case 400:
                     _handle_bad_request(err.response)
@@ -151,6 +196,8 @@ class Client:
                     _handle_not_found(err.response)
                 case 422:
                     _handle_unprocessable_entity(err.response)
+                case 429:
+                    _handle_too_many_requests(err.response)
                 case 500:
                     raise Error("internal server error")
                 case _:

{cecil-0.0.16 → cecil-0.0.18}/src/cecil/errors.py

@@ -47,6 +47,18 @@ def _handle_not_found(response):
     raise Error("resource not found", details)
 
 
+def _handle_too_many_requests(response):
+    if not _is_json(response.text):
+        raise Error("too many requests")
+
+    details = {}
+
+    for key, value in response.json().items():
+        details[_format_json_key(key)] = value
+
+    raise Error("too many requests", details)
+
+
 def _handle_unprocessable_entity(response):
     if not _is_json(response.text):
         raise Error(f"failed to process request")

{cecil-0.0.16 → cecil-0.0.18}/src/cecil/models.py

@@ -36,6 +36,11 @@ class DataRequestCreate(BaseModel):
     dataset_id: str
 
 
+class OrganisationCreate(BaseModel):
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+    name: str
+
+
 class RecoverAPIKey(BaseModel):
     model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
     message: str
@@ -72,8 +77,36 @@ class TransformationCreate(BaseModel):
     spatial_resolution: float
 
 
-class SnowflakeCredentials(BaseModel):
+class SnowflakeUserCredentials(BaseModel):
     model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
     account: SecretStr
     user: SecretStr
-    password: SecretStr
+    private_key: SecretStr
+
+
+class User(BaseModel):
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+    id: str
+    first_name: str
+    last_name: str
+    email: str
+    created_at: datetime.datetime
+    created_by: str
+
+
+class UserCreate(BaseModel):
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+    first_name: str
+    last_name: str
+    email: str
+
+
+class SignUpRequest(BaseModel):
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+    organisation: OrganisationCreate
+    user: UserCreate
+
+
+class SignUpResponse(BaseModel):
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+    message: str

cecil-0.0.18/src/cecil/version.py

@@ -0,0 +1 @@
+__version__ = "0.0.18"

cecil-0.0.16/src/cecil/version.py

@@ -1 +0,0 @@
-__version__ = "0.0.16"