[#2113] feat(pyClient): initial Gravitino Python client module

clients/client-python/Makefile

@@ -0,0 +1,13 @@
+.PHONY: mkvenv install test clean
+
+mkvenv:
+	python -m venv venv && source ./venv/bin/activate && pip install -U pip
+
+install:
+	source ./venv/bin/activate && pip install -e .
+
+test:
+	source ./venv/bin/activate && python -m unittest
+
+clean:
+	rm -rf venv

clients/client-python/README.md

@@ -5,9 +5,14 @@
 
 # Quick Start
 
-1. Install dependency
+1. Install current library in your local machine. 
     ```bash
-    pip install -r requirements.txt
+    pip install -e .
     ```
 
-2. After the packages is installed, you can simply run `pytest` in any directory inside gravitino/
+# Development Environment
+
+1. Install dependency
+    ```bash
+    pip install -e .[dev]
+    ```

clients/client-python/gravitino/__init__.py

@@ -0,0 +1,13 @@
+"""
+Copyright 2024 Datastrato Pvt Ltd.
+This software is licensed under the Apache License version 2.
+"""
+
+from gravitino.gravitino_client import (
+    GravitinoClient,
+    gravitino_metalake,
+    MetaLake,
+    Catalog,
+    Schema,
+    Table,
+)

clients/client-python/__init__.py → clients/client-python/gravitino/constants.py

@@ -1,4 +1,6 @@
 """
 Copyright 2024 Datastrato Pvt Ltd.
 This software is licensed under the Apache License version 2.
-"""
+"""
+
+TIMEOUT = 10

clients/client-python/tests/core/__init__.py → clients/client-python/gravitino/exceptions.py

@@ -1,4 +1,4 @@
 """
 Copyright 2024 Datastrato Pvt Ltd.
 This software is licensed under the Apache License version 2.
-"""
+"""

clients/client-python/gravitino/gravitino_client.py

@@ -0,0 +1,168 @@
+"""
+Copyright 2024 Datastrato Pvt Ltd.
+This software is licensed under the Apache License version 2.
+"""
+
+import re
+
+from gravitino.constants import TIMEOUT
+from gravitino.service import initialize_service, service
+from gravitino.typing import JSON_ro
+
+
+class MetaLake:
+    def __init__(self, payload: JSON_ro):
+        self.name = payload.get("name")
+        self.payload = payload
+        self.service = service["service"]
+        self.catalogs = self.service.get_catalogs(self.name)
+
+    def __repr__(self):
+        return f"MetaLake<{self.name}>"
+
+    def __getattr__(self, catalog_name):
+        if catalog_name in dir(self):
+            return Catalog(self.name, catalog_name)
+
+    def __dir__(self):
+        return [catalog["name"] for catalog in self.catalogs]
+
+
+class Catalog:
+    def __init__(self, metalake_name: str, catalog_name: str):
+        self.metalake_name = metalake_name
+        self.catalog_name = catalog_name
+        self.name = catalog_name
+        self.service = service["service"]
+        self.schemas = self.service.get_schemas(metalake_name, catalog_name)
+
+    def __repr__(self):
+        return f"Catalog<{self.name}>"
+
+    def __getattr__(self, schema_name):
+        if schema_name in dir(self):
+            return Schema(self.metalake_name, self.catalog_name, schema_name)
+
+    def __dir__(self):
+        return [schema["name"] for schema in self.schemas]
+
+
+class Schema:
+    def __init__(self, metalake_name: str, catalog_name: str, schema_name: str):
+        self.metalake_name = metalake_name
+        self.catalog_name = catalog_name
+        self.schema_name = schema_name
+        self.name = schema_name
+        self.service = service["service"]
+        self.tables = self.service.get_tables(metalake_name, catalog_name, schema_name)
+
+    def __repr__(self):
+        return f"Schema<{self.name}>"
+
+    def __getattr__(self, table_name):
+        if table_name in dir(self):
+            return Table(
+                self.metalake_name, self.catalog_name, self.schema_name, table_name
+            )
+
+    def __dir__(self):
+        return [table["name"] for table in self.tables]
+
+
+class Table:
+    def __init__(
+        self, metalake_name: str, catalog_name: str, schema_name: str, table_name: str
+    ):
+        self.metalake_name = metalake_name
+        self.catalog_name = catalog_name
+        self.schema_name = schema_name
+        self.table_name = table_name
+        self.name = schema_name
+        self.service = service["service"]
+
+    def __repr__(self):
+        return f"Table<{self.name}>"
+
+    def info(self):
+        return self.service.get_table(
+            self.metalake_name, self.catalog_name, self.schema_name, self.table_name
+        )
+
+
+class GravitinoClient:
+    def __init__(
+        self,
+        host: str,
+        *,
+        protocol: str = "http",
+        port: int = 8090,
+        prefix: str = "/api",
+        timeout: int = TIMEOUT,
+        debug: bool = False,
+    ) -> None:
+        if re.search(r"^https?:\/\/", host):
+            _host = host.rstrip("/")
+        else:
+            _host = f"{protocol}://{host.rstrip('/')}"
+
+        if not re.search(r"[0-9]{2,5}$", _host):
+            _host = f"{_host}:{port}"
+
+        _base_url = f"{_host}/{prefix.strip('/')}"
+        initialize_service(_base_url, timeout)
+        self.service = service["service"]
+        self.debug = debug
+
+    @classmethod
+    def initialize_metalake(
+        cls,
+        host: str,
+        metalake_name: str,
+        *,
+        protocol: str = "http",
+        port: int = 8090,
+        prefix: str = "/api",
+        timeout: int = TIMEOUT,
+        debug: bool = False,
+    ) -> MetaLake:
+        # keep in mind, all constructors should include same interface as __init__ function
+        client = cls(
+            host,
+            protocol=protocol,
+            port=port,
+            prefix=prefix,
+            timeout=timeout,
+            debug=debug,
+        )
+        return client.get_metalake(metalake_name)
+
+    @property
+    def version(self):
+        return self.service.get_version()
+
+    def get_metalakes(self) -> [MetaLake]:
+        return [MetaLake(metalake) for metalake in self.service.get_metalakes()]
+
+    def get_metalake(self, metalake: str) -> MetaLake:
+        return MetaLake(self.service.get_metalake(metalake))
+
+
+def gravitino_metalake(
+    host: str,
+    metalake_name: str,
+    *,
+    protocol: str = "http",
+    port: int = 8090,
+    prefix: str = "/api",
+    timeout: int = TIMEOUT,
+    debug: bool = False,
+) -> MetaLake:
+    return GravitinoClient.initialize_metalake(
+        host,
+        metalake_name,
+        protocol=protocol,
+        port=port,
+        prefix=prefix,
+        timeout=timeout,
+        debug=debug,
+    )

clients/client-python/gravitino/service.py

@@ -0,0 +1,77 @@
+"""
+Copyright 2024 Datastrato Pvt Ltd.
+This software is licensed under the Apache License version 2.
+"""
+
+from gravitino.utils import HTTPClient, unpack, Response
+from gravitino.constants import TIMEOUT
+
+
+class _Service:
+    def __init__(
+        self,
+        url: str,
+        timeout: int = TIMEOUT,
+    ) -> None:
+        self.http_client = HTTPClient(url, timeout=timeout)
+
+    @unpack("version")
+    def get_version(self) -> Response:
+        return self.http_client.get("/version")
+
+    @unpack("metalakes")
+    def get_metalakes(self) -> Response:
+        return self.http_client.get("/metalakes")
+
+    @unpack("metalake")
+    def get_metalake(self, metalake: str) -> Response:
+        return self.http_client.get(f"/metalakes/{metalake}")
+
+    @unpack("identifiers")
+    def get_catalogs(self, metalake: str) -> Response:
+        return self.http_client.get(f"/metalakes/{metalake}/catalogs/")
+
+    @unpack("catalog")
+    def get_catalog(self, metalake: str, catalog: str) -> Response:
+        return self.http_client.get(f"/metalakes/{metalake}/catalogs/{catalog}")
+
+    @unpack("identifiers")
+    def get_schemas(self, metalake: str, catalog: str) -> Response:
+        return self.http_client.get(f"/metalakes/{metalake}/catalogs/{catalog}/schemas")
+
+    @unpack("schema")
+    def get_schema(self, metalake: str, catalog: str, schema: str) -> Response:
+        return self.http_client.get(
+            f"/metalakes/{metalake}/catalogs/{catalog}/schemas/{schema}"
+        )
+
+    @unpack("identifiers")
+    def get_tables(self, metalake: str, catalog: str, schema: str) -> Response:
+        return self.http_client.get(
+            f"/metalakes/{metalake}/catalogs/{catalog}/schemas/{schema}/tables"
+        )
+
+    @unpack("table")
+    def get_table(
+        self, metalake: str, catalog: str, schema: str, table: str
+    ) -> Response:
+        return self.http_client.get(
+            f"/metalakes/{metalake}/catalogs/{catalog}/schemas/{schema}/tables/{table}"
+        )
+
+    @unpack("names")
+    def get_partitions(
+        self, metalake: str, catalog: str, schema: str, table: str
+    ) -> Response:
+        return self.http_client.get(
+            f"/metalakes/{metalake}/catalogs/{catalog}/schemas/{schema}/tables/{table}/partitions"
+        )
+
+
+service = {}
+
+
+def initialize_service(url: str, timeout: int = TIMEOUT):
+    global service
+    if not service:
+        service["service"] = _Service(url, timeout)

clients/client-python/gravitino/typing.py

@@ -0,0 +1,11 @@
+"""
+Copyright 2024 Datastrato Pvt Ltd.
+This software is licensed under the Apache License version 2.
+"""
+
+from typing import Mapping, Sequence, Union
+
+# https://github.com/python/typing/issues/182#issuecomment-1320974824
+JSON_ro = Union[
+    Mapping[str, "JSON_ro"], Sequence["JSON_ro"], str, int, float, bool, None
+]

clients/client-python/gravitino_client/core/__init__.py → clients/client-python/gravitino/utils/__init__.py

@@ -2,5 +2,4 @@
 Copyright 2024 Datastrato Pvt Ltd.
 This software is licensed under the Apache License version 2.
 """
-from .gravitino_client import GravitinoClient
-from .dto import VersionDTO
+from gravitino.utils.http_client import Response, HTTPClient, unpack