Merge branch 'feature/add-connection' into develop

Author: Charles Larivier

.github/workflows/python-package.yml renamed to .github/workflows/main.yml

@@ -1,13 +1,16 @@
 # This workflow will install Python dependencies, run tests and lint with a variety of Python versions
 # For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
 
-name: Python package
+name: main
 
 on:
   push:
-    branches: [ main ]
+    branches:
+      - main
   pull_request:
-    branches: [ main ]
+    branches:
+      - main
+      - develop
 
 jobs:
   build:
@@ -16,19 +19,41 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.8", "3.9", "3.10"]
+        python-version: ["3.6", "3.7", "3.8", "3.9", "3.10"]
+        os: [ubuntu-latest, macos-latest, windows-latest]
+
+    services:
+      metabase:
+        image: metabase/metabase
+        ports:
+          - 3000:3000
 
     steps:
     - uses: actions/checkout@v2
+
     - name: Set up Python ${{ matrix.python-version }}
       uses: actions/setup-python@v2
       with:
         python-version: ${{ matrix.python-version }}
+
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
         python -m pip install pipenv
-        pipenv install --deploy
+        pipenv install --deploy --dev
+
+    - name: Wait for Metabase to be initialized
+      run: sleep 60s
+      shell: bash
+
     - name: Test with pytest
       run: |
-        pipenv run pytest
+        pipenv run pytest --cov=./ --cov-report=xml
+
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v2
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
+        directory: ./
+        env_vars: OS,PYTHON
+        fail_ci_if_error: true

.gitignore

@@ -139,4 +139,6 @@ dmypy.json
 # Cython debug symbols
 cython_debug/
 
-.idea
+
+.idea/
+/metabase/_version.py

.pre-commit-config.yaml

@@ -0,0 +1,18 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.2.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+
+  - repo: https://github.com/psf/black
+    rev: 21.11b0
+    hooks:
+      - id: black
+
+  - repo: https://github.com/PyCQA/isort
+    rev: 5.10.1
+    hooks:
+      - id: isort

Makefile

@@ -0,0 +1,3 @@
+dev:
+	@pipenv install --dev --pre
+	@pipenv run pre-commit install

Pipfile

@@ -4,6 +4,7 @@ verify_ssl = true
 name = "pypi"
 
 [packages]
+metabase-python = {editable = true, path = "."}
 
 [dev-packages]
 pre-commit = "*"

Pipfile.lock

@@ -1 +1,4 @@
 # Metabase Python
+[![main](https://github.com/chasleslr/metabase-python/actions/workflows/main.yml/badge.svg)](https://github.com/chasleslr/metabase-python/actions/workflows/main.yml)
+[![codecov](https://codecov.io/gh/chasleslr/metabase-python/branch/main/graph/badge.svg?token=15G7HOQ1CM)](https://codecov.io/gh/chasleslr/metabase-python)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

README.md

@@ -0,0 +1,6 @@
+version: "3.9"
+services:
+  metabase:
+    image: metabase/metabase
+    ports:
+    - 3000:3000

docker-compose.yml

@@ -0,0 +1,9 @@
+from metabase.metabase import Metabase
+from metabase.resources.dataset import Dataset
+from metabase.resources.field import Field
+from metabase.resources.metric import Metric
+from metabase.resources.permission_group import PermissionGroup
+from metabase.resources.permission_membership import PermissionMembership
+from metabase.resources.segment import Segment
+from metabase.resources.table import Table
+from metabase.resources.user import User

metabase/__init__.py

@@ -0,0 +1,2 @@
+class NotFoundError(Exception):
+    pass

metabase/exceptions.py

@@ -0,0 +1,65 @@
+from weakref import WeakValueDictionary
+
+import requests
+
+
+class Singleton(type):
+    _instances = WeakValueDictionary()
+
+    def __call__(cls, *args, **kw):
+        if cls not in cls._instances:
+            instance = super(Singleton, cls).__call__(*args, **kw)
+            cls._instances[cls] = instance
+        return cls._instances[cls]
+
+
+class Metabase(metaclass=Singleton):
+    def __init__(self, host: str, user: str, password: str, token: str = None):
+        self._host = host
+        self.user = user
+        self.password = password
+        self._token = token
+
+    @property
+    def host(self):
+        host = self._host
+
+        if not host.startswith("http"):
+            host = "https://" + self._host
+
+        return host.rstrip("/")
+
+    @host.setter
+    def host(self, value):
+        self._host = value
+
+    @property
+    def token(self):
+        if self._token is None:
+            response = requests.post(
+                self.host + "/api/session",
+                json={"username": self.user, "password": self.password},
+            )
+            self._token = response.json()["id"]
+
+        return self._token
+
+    @token.setter
+    def token(self, value):
+        self._token = value
+
+    @property
+    def headers(self):
+        return {"X-Metabase-Session": self.token}
+
+    def get(self, endpoint: str, **kwargs):
+        return requests.get(self.host + endpoint, headers=self.headers, **kwargs)
+
+    def post(self, endpoint: str, **kwargs):
+        return requests.post(self.host + endpoint, headers=self.headers, **kwargs)
+
+    def put(self, endpoint: str, **kwargs):
+        return requests.put(self.host + endpoint, headers=self.headers, **kwargs)
+
+    def delete(self, endpoint: str, **kwargs):
+        return requests.delete(self.host + endpoint, headers=self.headers, **kwargs)

metabase/metabase.py

@@ -0,0 +1,2 @@
+class MISSING:
+    pass

metabase/missing.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from exceptions import NotFoundError
+from requests import HTTPError
+
+from metabase import Metabase
+from metabase.missing import MISSING
+
+
+class Resource:
+    ENDPOINT: str
+    PRIMARY_KEY: str = "id"
+
+    def __init__(self, **kwargs):
+        self._attributes = []
+
+        for k, v in kwargs.items():
+            self._attributes.append(k)
+            setattr(self, k, v)
+
+    def __repr__(self):
+        # move primary key to beginning of the list
+        attributes = self._attributes.copy()
+        if self.PRIMARY_KEY is not None:
+            attributes.insert(0, attributes.pop(attributes.index(self.PRIMARY_KEY)))
+
+        return (
+            self.__class__.__qualname__
+            + "("
+            + ", ".join([f"{attr}={getattr(self, attr)}" for attr in attributes])
+            + ")"
+        )
+
+    @staticmethod
+    def connection() -> Metabase:
+        return Metabase()
+
+
+class ListResource(Resource):
+    @classmethod
+    def list(cls):
+        """List all instances."""
+        response = cls.connection().get(cls.ENDPOINT)
+        records = [cls(**record) for record in response.json()]
+        return records
+
+
+class GetResource(Resource):
+    @classmethod
+    def get(cls, id: int):
+        """Get a single instance by ID."""
+        response = cls.connection().get(cls.ENDPOINT + f"/{id}")
+
+        if response.status_code == 404 or response.status_code == 204:
+            raise NotFoundError(f"{cls.__name__}(id={id}) was not found.")
+
+        return cls(**response.json())
+
+
+class CreateResource(Resource):
+    @classmethod
+    def create(cls, **kwargs):
+        """Create an instance and save it."""
+        response = cls.connection().post(cls.ENDPOINT, json=kwargs)
+
+        if response.status_code not in (200, 202):
+            raise HTTPError(response.content.decode())
+
+        return cls(**response.json())
+
+
+class UpdateResource(Resource):
+    def update(self, **kwargs) -> None:
+        """
+        Update an instance by providing function arguments.
+        Providing any argument with metabase.MISSING will result in this argument being
+        ignored from the request.
+        """
+        params = {k: v for k, v in kwargs.items() if v != MISSING}
+        response = self.connection().put(
+            self.ENDPOINT + f"/{getattr(self, self.PRIMARY_KEY)}", json=params
+        )
+
+        if response.status_code != 200:
+            raise HTTPError(response.json())
+
+        for k, v in kwargs.items():
+            setattr(self, k, v)
+
+
+class DeleteResource(Resource):
+    def delete(self) -> None:
+        """Delete an instance."""
+        response = self.connection().delete(
+            self.ENDPOINT + f"/{getattr(self, self.PRIMARY_KEY)}"
+        )
+
+        if response.status_code not in (200, 204):
+            raise HTTPError(response.content.decode())

metabase/resource.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, List
+
+import pandas as pd
+
+from metabase.resource import CreateResource, Resource
+
+
+class Data(Resource):
+    ENDPOINT = None
+    PRIMARY_KEY = None
+
+    rows: List[List[Any]]
+    cols: dict
+    native_form: dict
+
+    def to_pandas(self):
+        """Returns the query results as a Pandas DataFrame."""
+        columns = [col["display_name"] for col in self.cols]
+        return pd.DataFrame(data=self.rows, columns=columns)
+
+
+class Dataset(CreateResource):
+    ENDPOINT = "/api/dataset"
+    PRIMARY_KEY = None
+
+    context: str
+    status: str
+    database_id: int
+    data: Data
+    row_count: int
+
+    started_at: str
+    running_time: int
+    json_query: str
+    average_execution_time: int = None
+
+    @classmethod
+    def create(cls, database: int, type: str, query: dict, **kwargs) -> Dataset:
+        dataset = super(Dataset, cls).create(database=database, type=type, query=query)
+        dataset.data = Data(**dataset.data)
+        return dataset
+
+    def to_pandas(self) -> pd.DataFrame:
+        """Returns the query results as a Pandas DataFrame."""
+        return self.data.to_pandas()