Merge pull request #1 from posit-dev/tdstein/add-config

feat: adds boilerplate for config with factories.

Author: tdstein

.coveragerc

@@ -0,0 +1,2 @@
+[report]
+    fail_under = 100

.github/workflows/test.yaml

@@ -0,0 +1,24 @@
+name: Test
+on: [push]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version:
+          - '3.8'
+          - '3.9'
+          - '3.10'
+          - '3.11'
+          - '3.12'
+    steps:
+    - uses: actions/checkout@v4
+    - uses: extractions/setup-just@v1
+    - uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+    - run: just deps
+    - run: just test
+    - run: just cov
+    - run: just lint

.gitignore

@@ -85,7 +85,7 @@ ipython_config.py
 # pyenv
 #   For a library or package, you might want to ignore these files since the code is
 #   intended to run in multiple environments; otherwise, check them in:
-# .python-version
+.python-version
 
 # pipenv
 #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
@@ -161,3 +161,6 @@ cython_debug/
 
 # Version file
 /src/posit/_version.py
+
+# Ruff
+.ruff_cache/

.pre-commit-config.yaml

@@ -0,0 +1,13 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+  - repo: local
+    hooks:
+      - id: format
+        name: format
+        entry: bash -c "just fmt"
+        language: system
+      - id: lint
+        name: lint
+        entry: bash -c "just lint"
+        language: system

Justfile

@@ -11,10 +11,10 @@ default:
     #!/usr/bin/env bash
     {{ OPTIONS }}
 
-    just clean
     just deps
     just test
     just cov
+    just lint
     just build
 
 build:
@@ -23,7 +23,6 @@ build:
 
     {{ PYTHON }} -m build
 
-
 cov *args="report":
     #!/usr/bin/env bash
     {{ OPTIONS }}
@@ -34,11 +33,14 @@ clean:
     #!/usr/bin/env bash
     {{ OPTIONS }}
 
+    find . -name "*.egg-info" -exec rm -rf {} +
     find . -name "*.pyc" -exec rm -f {} +
     find . -name "__pycache__" -exec rm -rf {} +
     rm -rf\
         .coverage\
+        .mypy_cache\
         .pytest_cache\
+        .ruff_cache\
         *.egg-info\
         build\
         dist\
@@ -50,6 +52,19 @@ deps:
 
     {{ PIP }} install -e '.[test]'
 
+fmt:
+    #!/usr/bin/env bash
+    {{ OPTIONS }}
+
+    {{ PYTHON }} -m ruff format .
+
+lint:
+    #!/usr/bin/env bash
+    {{ OPTIONS }}
+
+    {{ PYTHON }} -m mypy --install-types --non-interactive .
+    {{ PYTHON }} -m ruff check
+
 test:
     #!/usr/bin/env bash
     {{ OPTIONS }}

pyproject.toml

@@ -19,13 +19,15 @@ classifiers = [
 ]
 dynamic = ["version"]
 dependencies = [
-    "requests==2.31.0"
+    "requests>=2.31.0,<3"
 ]
 
 [project.optional-dependencies]
 test = [
     "coverage",
+    "mypy",
     "pytest",
+    "ruff",
     "setuptools-scm"
 ]
 

src/posit/auth.py

@@ -0,0 +1,11 @@
+from requests import PreparedRequest
+from requests.auth import AuthBase
+
+
+class Auth(AuthBase):
+    def __init__(self, key) -> None:
+        self.key = key
+
+    def __call__(self, r: PreparedRequest) -> PreparedRequest:
+        r.headers["Authorization"] = f"Key {self.key}"
+        return r

src/posit/auth_test.py

@@ -0,0 +1,13 @@
+from unittest.mock import Mock
+
+from .auth import Auth
+
+
+class TestAuth:
+    def test_auth_headers(self):
+        key = "foobar"
+        auth = Auth(key=key)
+        r = Mock()
+        r.headers = {}
+        auth(r)
+        assert r.headers == {"Authorization": f"Key {key}"}

src/posit/client.py

@@ -0,0 +1,22 @@
+from requests import Session
+from typing import Optional
+
+from .auth import Auth
+from .config import ConfigBuilder
+
+
+class Client:
+    def __init__(
+        self, endpoint: Optional[str] = None, api_key: Optional[str] = None
+    ) -> None:
+        builder = ConfigBuilder()
+        builder.set_api_key(api_key)
+        builder.set_endpoint(endpoint)
+        self._config = builder.build()
+        self._session = Session()
+        self._session.auth = Auth(self._config.api_key)
+
+    def get(self, endpoint: str, *args, **kwargs):  # pragma: no cover
+        return self._session.request(
+            "GET", f"{self._config.endpoint}/{endpoint}", *args, **kwargs
+        )

src/posit/client_test.py

@@ -0,0 +1,26 @@
+from unittest.mock import MagicMock, Mock, patch
+
+from .client import Client
+
+
+class TestClient:
+    @patch("posit.client.Session")
+    @patch("posit.client.ConfigBuilder")
+    @patch("posit.client.Auth")
+    def test_init(self, Auth: MagicMock, ConfigBuilder: MagicMock, Session: MagicMock):
+        api_key = "foobar"
+        endpoint = "http://foo.bar"
+        config = Mock()
+        config.api_key = api_key
+        builder = ConfigBuilder.return_value
+        builder.set_api_key = Mock()
+        builder.set_endpoint = Mock()
+        builder.build = Mock(return_value=config)
+        client = Client(api_key=api_key, endpoint=endpoint)
+        ConfigBuilder.assert_called_once()
+        builder.set_api_key.assert_called_once_with(api_key)
+        builder.set_endpoint.assert_called_once_with(endpoint)
+        builder.build.assert_called_once()
+        Session.assert_called_once()
+        Auth.assert_called_once_with(api_key)
+        assert client._config == config

src/posit/config.py

@@ -0,0 +1,54 @@
+import os
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import List, Optional
+
+
+@dataclass
+class Config:
+    api_key: Optional[str] = None
+    endpoint: Optional[str] = None
+
+
+class ConfigProvider(ABC):
+    @abstractmethod
+    def get_value(self, key: str) -> Optional[str]:
+        raise NotImplementedError  # pragma: no cover
+
+
+class EnvironmentConfigProvider(ConfigProvider):
+    def get_value(self, key: str) -> Optional[str]:
+        if key == "api_key":
+            return os.environ.get("CONNECT_API_KEY")
+
+        if key == "endpoint":
+            return os.environ.get("CONNECT_SERVER")
+
+        return None
+
+
+class ConfigBuilder:
+    def __init__(
+        self, providers: List[ConfigProvider] = [EnvironmentConfigProvider()]
+    ) -> None:
+        self._config = Config()
+        self._providers = providers
+
+    def build(self) -> Config:
+        for key in Config.__annotations__:
+            if not getattr(self._config, key):
+                setattr(
+                    self._config,
+                    key,
+                    next(
+                        (provider.get_value(key) for provider in self._providers), None
+                    ),
+                )
+        return self._config
+
+    def set_api_key(self, api_key: Optional[str]):
+        self._config.api_key = api_key
+
+    def set_endpoint(self, endpoint: Optional[str]):
+        self._config.endpoint = endpoint

src/posit/config_test.py

@@ -0,0 +1,46 @@
+from unittest.mock import Mock, patch
+
+from .config import Config, ConfigBuilder, EnvironmentConfigProvider
+
+
+class TestEnvironmentConfigProvider:
+    @patch.dict("os.environ", {"CONNECT_API_KEY": "foobar"})
+    def test_get_api_key(self):
+        provider = EnvironmentConfigProvider()
+        api_key = provider.get_value("api_key")
+        assert api_key == "foobar"
+
+    @patch.dict("os.environ", {"CONNECT_SERVER": "http://foo.bar"})
+    def test_get_endpoint(self):
+        provider = EnvironmentConfigProvider()
+        endpoint = provider.get_value("endpoint")
+        assert endpoint == "http://foo.bar"
+
+    def test_get_value_miss(self):
+        provider = EnvironmentConfigProvider()
+        value = provider.get_value("foobar")
+        assert value is None
+
+
+class TestConfigBuilder:
+    def test_build(self):
+        builder = ConfigBuilder()
+        assert builder._config == Config()
+
+    def test_build_with_provider(self):
+        provider = Mock()
+        provider.get_value = Mock()
+        builder = ConfigBuilder([provider])
+        builder.build()
+        for key in Config.__annotations__:
+            provider.get_value.assert_any_call(key)
+
+    def test_set_api_key(self):
+        builder = ConfigBuilder()
+        builder.set_api_key("foobar")
+        assert builder._config.api_key == "foobar"
+
+    def test_set_endpoint(self):
+        builder = ConfigBuilder()
+        builder.set_endpoint("http://foo.bar")
+        assert builder._config.endpoint == "http://foo.bar"