feature_gate 0.0.1__tar.gz

feature_gate-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Deft Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

feature_gate-0.0.1/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.1
+Name: feature_gate
+Version: 0.0.1
+Summary: An extensible feature flagging library for Python
+Home-page: https://github.com/deftinc/feature_gate
+License: MIT
+Keywords: feature flags,feature gate
+Author: Patrick Wiseman
+Author-email: patrick@deft.services
+Maintainer: Patrick Wiseman
+Maintainer-email: patrick@deft.services
+Requires-Python: >=3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: structlog (>=24.1.0,<25.0.0)
+Project-URL: Repository, https://github.com/deftinc/feature_gate
+Description-Content-Type: text/markdown
+
+# FeatureGate
+
+Featuregate is a simple feature flag API similar to [Flipper](https://github.com/flippercloud/flipper).
+
+## Configuration
+
+### PosthogAdapter
+
+```bash
+export POSTHOG_API_KEY="someapikey"
+export POSTHOG_PROJECT_ID="someprojectid"
+```
+
+## Usage
+
+```python
+from feature_gate.client import Client
+from feature_gate.adapters import PosthogAdapter
+from feature_gate.feature import Feature
+
+adapter = PosthogAdapter() # Or MemoryAdapter for testing
+client = Client(adapter)
+feature = Feature("Test flag", "test_flag", "This is a test flag")
+
+client.features()
+# => []
+
+client.add(feature)
+# => True
+
+client.features()
+# => ["test_flag"]
+
+client.is_enabled("test_flag")
+# => False
+
+client.enable("test_flag")
+# => True
+
+client.is_enabled("test_flag")
+# => True
+
+client.disable("test_flag")
+# => True
+
+client.is_enabled("test_flag")
+# => False
+
+client.remove("test_flag")
+# => True
+
+client.features()
+# => []
+```
+
+## Errors
+
+### FeatureNotFound
+If you try to run something that presumes the existence of a feature and it can't find it it'll throw a `FeatureNotFound`.
+
+```python
+from feature_gate.client import FeatureNotFound
+
+try:
+  client.remove("some_feature_that_definitely_does_not_exist")
+except FeatureNotFound as err:
+  # Do what we want to do when the feature doesn't exist
+```
+
+### PostApiClientError
+For the `PosthogAdapter` in particular it will raise error if it was unable to reach the Posthog API. These get bubbled up as `PosthogAPIClientError`.
+
+```python
+from feature_gate.clients.posthog_api_client import PosthogAPIClientError
+
+try:
+  client.features() #disable network connection
+except PosthogAPIClientError as err:
+  # Handle the error -- define default behavior in outage
+```
+
+## Testing
+
+The Memory Adapter can be used for writing tests. This creates an ephemeral memory only implementation of the feature_gate client API. This is non-suitable for production only for tests.
+
+```python
+from feature_gate.client import Client
+from feature_gate.adapters.memory import MemoryAdapter
+
+client = Client(MemoryAdapter())
+```
+
+## Developing this library
+
+### Hot-reload the REPL
+
+Hot-reload the client in the repl for development:
+
+```
+$ repl
+>>> exec(open('reload.py').read())
+```
+

feature_gate-0.0.1/README.md

@@ -0,0 +1,102 @@
+# FeatureGate
+
+Featuregate is a simple feature flag API similar to [Flipper](https://github.com/flippercloud/flipper).
+
+## Configuration
+
+### PosthogAdapter
+
+```bash
+export POSTHOG_API_KEY="someapikey"
+export POSTHOG_PROJECT_ID="someprojectid"
+```
+
+## Usage
+
+```python
+from feature_gate.client import Client
+from feature_gate.adapters import PosthogAdapter
+from feature_gate.feature import Feature
+
+adapter = PosthogAdapter() # Or MemoryAdapter for testing
+client = Client(adapter)
+feature = Feature("Test flag", "test_flag", "This is a test flag")
+
+client.features()
+# => []
+
+client.add(feature)
+# => True
+
+client.features()
+# => ["test_flag"]
+
+client.is_enabled("test_flag")
+# => False
+
+client.enable("test_flag")
+# => True
+
+client.is_enabled("test_flag")
+# => True
+
+client.disable("test_flag")
+# => True
+
+client.is_enabled("test_flag")
+# => False
+
+client.remove("test_flag")
+# => True
+
+client.features()
+# => []
+```
+
+## Errors
+
+### FeatureNotFound
+If you try to run something that presumes the existence of a feature and it can't find it it'll throw a `FeatureNotFound`.
+
+```python
+from feature_gate.client import FeatureNotFound
+
+try:
+  client.remove("some_feature_that_definitely_does_not_exist")
+except FeatureNotFound as err:
+  # Do what we want to do when the feature doesn't exist
+```
+
+### PostApiClientError
+For the `PosthogAdapter` in particular it will raise error if it was unable to reach the Posthog API. These get bubbled up as `PosthogAPIClientError`.
+
+```python
+from feature_gate.clients.posthog_api_client import PosthogAPIClientError
+
+try:
+  client.features() #disable network connection
+except PosthogAPIClientError as err:
+  # Handle the error -- define default behavior in outage
+```
+
+## Testing
+
+The Memory Adapter can be used for writing tests. This creates an ephemeral memory only implementation of the feature_gate client API. This is non-suitable for production only for tests.
+
+```python
+from feature_gate.client import Client
+from feature_gate.adapters.memory import MemoryAdapter
+
+client = Client(MemoryAdapter())
+```
+
+## Developing this library
+
+### Hot-reload the REPL
+
+Hot-reload the client in the repl for development:
+
+```
+$ repl
+>>> exec(open('reload.py').read())
+```

feature_gate-0.0.1/feature_gate/adapters/memory.py

@@ -0,0 +1,79 @@
+import structlog
+from pathlib import Path
+from feature_gate.client import FeatureNotFound
+
+from structlog.contextvars import (
+    bind_contextvars,
+    merge_contextvars,
+    bound_contextvars,
+)
+
+class MemoryAdapter:
+  def __init__(self):
+    self._features = []
+    bind_contextvars(klass="MemoryAdapter")
+    structlog.configure(
+      processors=[
+        merge_contextvars,
+        structlog.processors.add_log_level,
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.processors.dict_tracebacks,
+        structlog.processors.JSONRenderer(),
+      ],
+      logger_factory=structlog.WriteLoggerFactory(
+        file=Path("development").with_suffix(".log").open("wt")
+      ),
+    )
+    self._logger = structlog.get_logger()
+
+  def add(self, feature):
+    self._logger.info("Add feature key={feature.key}")
+    if feature.key not in self._features:
+      self._features.append({
+        "name": feature.name,
+        "key": feature.key,
+        "description": feature.description,
+        "gates": {
+          "boolean": {
+            "enabled": False
+          }
+        }
+      })
+    return True
+
+  def remove(self, feature_key):
+    self._logger.info("Remove feature key={feature.key}")
+    for feature in self._features:
+      if feature["key"] == feature_key:
+        self._features.remove(feature)
+        return True
+    raise FeatureNotFound("Feature {feature_key} not found.")
+
+  def features(self):
+    features = [feature["key"] for feature in self._features]
+    self._logger.info("Lists features {features}")
+    return features
+
+  def is_enabled(self, feature_key):
+    for feature in self._features:
+      if feature["key"] == feature_key:
+        is_enabled = feature["gates"]["boolean"]["enabled"]
+        self._logger.info("Check feature key={feature.key} enabled={is_enabled}")
+        return is_enabled
+    raise FeatureNotFound("Feature {feature_key} not found.")
+
+  def enable(self, feature_key):
+    self._logger.info("Enable feature key={feature.key}")
+    for feature in self._features:
+      if feature["key"] == feature_key:
+        feature["gates"]["boolean"]["enabled"] = True
+        return True
+    raise FeatureNotFound("Feature {feature_key} not found.")
+
+  def disable(self, feature_key):
+    self._logger.info("Disable feature key={feature.key}")
+    for feature in self._features:
+      if feature["key"] == feature_key:
+        feature["gates"]["boolean"]["enabled"] = False
+        return True
+    raise FeatureNotFound("Feature {feature_key} not found.")

feature_gate-0.0.1/feature_gate/adapters/posthog.py

@@ -0,0 +1,108 @@
+from feature_gate.clients.posthog_api_client import PosthogAPIClient
+class PosthogAdapter:
+  def __init__(self, api_key=None, project_id=None):
+    self.client = PosthogAPIClient(api_key=api_key, project_id=project_id)
+
+  def client(self):
+    return self.client
+
+  def add(self, feature):
+    if self.client.fetch_feature(feature.key) is None:
+      self.client.create_feature(feature.key, feature.description)
+    return True
+
+  def remove(self, feature_key):
+    if not self.client.fetch_feature(feature_key) is None:
+      self.client.delete_feature(feature_key)
+    return True
+
+  def features(self):
+    resp = self.client.list_features()
+    key='key'
+    return [item[key] for item in resp["data"] if key in item]
+
+  def is_enabled(self, feature_key):
+    return self.client.is_enabled(feature_key)
+
+  def enable(self, feature_key):
+    resp = self.client.enable_feature(feature_key)
+    return resp["data"]["active"]
+
+  def disable(self, feature_key):
+    resp = self.client.disable_feature(feature_key)
+    return resp["data"]["active"] == False
+
+  # def enable_expression(self, expression):
+  #   raise NotImplementedError
+
+  # def disable_expression(self, expression):
+  #   raise NotImplementedError
+
+  # def expression(self):
+  #   raise NotImplementedError
+
+  # def add_expression(self, expression):
+  #   raise NotImplementedError
+
+  # def remove_expression(self, expression):
+  #   raise NotImplementedError
+
+  # def enable_actor(self, feature, actor):
+  #   raise NotImplementedError
+
+  # def disable_actor(self, feature, actor):
+  #   raise NotImplementedError
+
+  # def enable_group(self, feature, group):
+  #   raise NotImplementedError
+
+  # def disable_group(self, feature, group):
+  #   raise NotImplementedError
+
+  # def enable_percentage_of_actors(self, feature, percentage):
+  #   raise NotImplementedError
+
+  # def disable_percentage_of_actors(self, feature, percentage):
+  #   raise NotImplementedError
+
+  # def enable_percentage_of_time(self, feature, percentage):
+  #   raise NotImplementedError
+
+  # def disable_percentage_of_time(self, feature, percentage):
+  #   raise NotImplementedError
+
+  # def feature(self):
+  #   raise NotImplementedError
+
+  # # def [](self):
+  # #   raise NotImplementedError
+
+  # def preload(self):
+  #   raise NotImplementedError
+
+  # def preload_all(self):
+  #   raise NotImplementedError
+
+  # def adapter(self):
+  #   raise NotImplementedError
+
+  # def do_import(self):
+  #   raise NotImplementedError
+
+  # def do_export(self):
+  #   raise NotImplementedError
+
+  # def memoize(self):
+  #   raise NotImplementedError
+
+  # def is_memorizing(self):
+  #   raise NotImplementedError
+
+  # def is_read_only(self):
+  #   raise NotImplementedError
+
+  # def sync(self):
+  #   raise NotImplementedError
+
+  # def sync_secret(self):
+  #   raise NotImplementedError

feature_gate-0.0.1/feature_gate/client.py

@@ -0,0 +1,102 @@
+class FeatureNotFound(ValueError):
+  pass
+
+class Client:
+  def __init__(self, adapter):
+    self.adapter = adapter
+
+  def adapter(self):
+    return self.adapter
+
+  def add(self, feature):
+    return self.adapter.add(feature)
+
+  def remove(self, feature):
+    return self.adapter.remove(feature)
+
+  def features(self):
+    return self.adapter.features()
+
+  def is_enabled(self, feature):
+    return self.adapter.is_enabled(feature)
+
+  def enable(self, feature):
+    return self.adapter.enable(feature)
+
+  def disable(self, feature):
+    return self.adapter.disable(feature)
+
+  # def enable_expression(self, expression):
+  #   raise NotImplementedError
+
+  # def disable_expression(self, expression):
+  #   raise NotImplementedError
+
+  # def expression(self):
+  #   raise NotImplementedError
+
+  # def add_expression(self, expression):
+  #   raise NotImplementedError
+
+  # def remove_expression(self, expression):
+  #   raise NotImplementedError
+
+  # def enable_actor(self, feature, actor):
+  #   raise NotImplementedError
+
+  # def disable_actor(self, feature, actor):
+  #   raise NotImplementedError
+
+  # def enable_group(self, feature, group):
+  #   raise NotImplementedError
+
+  # def disable_group(self, feature, group):
+  #   raise NotImplementedError
+
+  # def enable_percentage_of_actors(self, feature, percentage):
+  #   raise NotImplementedError
+
+  # def disable_percentage_of_actors(self, feature, percentage):
+  #   raise NotImplementedError
+
+  # def enable_percentage_of_time(self, feature, percentage):
+  #   raise NotImplementedError
+
+  # def disable_percentage_of_time(self, feature, percentage):
+  #   raise NotImplementedError
+
+  # def feature(self):
+  #   raise NotImplementedError
+
+  # # def [](self):
+  # #   raise NotImplementedError
+
+  # def preload(self):
+  #   raise NotImplementedError
+
+  # def preload_all(self):
+  #   raise NotImplementedError
+
+  # def adapter(self):
+  #   raise NotImplementedError
+
+  # def do_import(self):
+  #   raise NotImplementedError
+
+  # def do_export(self):
+  #   raise NotImplementedError
+
+  # def memoize(self):
+  #   raise NotImplementedError
+
+  # def is_memorizing(self):
+  #   raise NotImplementedError
+
+  # def is_read_only(self):
+  #   raise NotImplementedError
+
+  # def sync(self):
+  #   raise NotImplementedError
+
+  # def sync_secret(self):
+  #   raise NotImplementedError

feature_gate-0.0.1/feature_gate/clients/posthog_api_client.py

@@ -0,0 +1,235 @@
+import json
+import os
+import requests
+import structlog
+
+from pathlib import Path
+from feature_gate.client import FeatureNotFound
+
+from structlog.contextvars import (
+    bind_contextvars,
+    merge_contextvars,
+    bound_contextvars,
+)
+
+class PosthogAPIClientError(Exception):
+  pass
+
+class PosthogAPIClient:
+  def __init__(self, api_base=None, api_key=None, project_id=None):
+    if api_base is None:
+      self.api_base = os.environ.get("POSTHOG_API_BASE", "https://app.posthog.com")
+    else:
+      self.api_base = api_base
+
+    if api_key is None:
+      self.api_key = os.environ.get('POSTHOG_API_KEY')
+    else:
+      self.api_key = api_key
+
+    if project_id is None:
+      self.project_id = os.environ.get('POSTHOG_PROJECT_ID')
+    else:
+      self.project_id = project_id
+
+    bind_contextvars(klass="PosthogAPIClient", project_id=project_id)
+    structlog.configure(
+      processors=[
+        merge_contextvars,
+        structlog.processors.add_log_level,
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.processors.dict_tracebacks,
+        structlog.processors.JSONRenderer(),
+      ],
+      logger_factory=structlog.WriteLoggerFactory(
+        file=Path("development").with_suffix(".log").open("wt")
+      ),
+    )
+    self.logger = structlog.get_logger()
+
+  def api_base(self):
+    return self.api_base
+
+  def api_key(self):
+     return self.api_key
+
+  def project_id(self):
+    return self.project_id
+
+  def list_features(self):
+    path = f'/api/projects/{self.project_id}/feature_flags'
+    with bound_contextvars(method="list_features"):
+      response = self._get(path)
+      return self._map_list_response("GET", path, response)
+
+  def create_feature(self, name, description, deleted=False, active=False):
+    with bound_contextvars(method="create_feature"):
+      path = f'/api/projects/{self.project_id}/feature_flags'
+      payload = {
+        'name': description,
+        'key': name,
+        'deleted': deleted,
+        'active': active
+      }
+      response = self._post(path, payload)
+      return self._map_single_response("POST", path, response)
+
+  def fetch_feature(self, key):
+    features = self.list_features()["data"]
+    for entry in features:
+        if "key" in entry and entry["key"] == key:
+            return entry
+    return None
+
+  def delete_feature(self, key):
+    feature = self.fetch_feature(key)
+    if feature == None:
+      raise FeatureNotFound(f"Feature {key} not found")
+    else:
+      path = f'/api/projects/{self.project_id}/feature_flags/{feature["id"]}'
+      with bound_contextvars(method="delete_feature"):
+        payload = {
+          'deleted': True
+        }
+        response = self._patch(path, payload)
+        return self._map_single_response("PATCH", path, response)
+
+  def is_enabled(self, key):
+    feature = self.fetch_feature(key)
+    if feature == None:
+      raise FeatureNotFound(f"Feature {key} not found")
+    else:
+      return feature["active"]
+
+  def enable_feature(self, key):
+    feature = self.fetch_feature(key)
+    if feature == None:
+      raise FeatureNotFound(f"Feature {key} not found")
+    else:
+      path = f'/api/projects/{self.project_id}/feature_flags/{feature["id"]}'
+      with bound_contextvars(method="enable_feature"):
+        payload = {
+          'active': True
+        }
+        response = self._patch(path, payload)
+        return self._map_single_response("PATCH", path, response)
+
+  def disable_feature(self, key):
+    feature = self.fetch_feature(key)
+    if feature == None:
+      raise FeatureNotFound(f"Feature {key} not found")
+    else:
+      path = f'/api/projects/{self.project_id}/feature_flags/{feature["id"]}'
+      with bound_contextvars(method="disable_feature"):
+        payload = {
+          'active': False
+        }
+        response = self._patch(path, payload)
+        return self._map_single_response("PATCH", path, response)
+
+  def _get(self, path):
+    try:
+      return self.__get(path)
+    except requests.ConnectionError as err:
+      self._log_posthog_connection_error(err)
+
+  def __get(self, path):
+    with bound_contextvars(method="get"):
+      url = f"{self.api_base}{path}"
+      headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {self.api_key}"
+      }
+      response = requests.get(url, headers=headers)
+      return response
+
+  def _post(self, path, payload):
+    try:
+      return self.__post(path, payload)
+    except requests.ConnectionError as err:
+      self._log_posthog_connection_error(err)
+
+  def __post(self, path, payload):
+    url = f"{self.api_base}{path}"
+    with bound_contextvars(method="post", url=url):
+      json_payload = json.dumps(payload)
+      headers = self._get_headers()
+      response = requests.post(url, data=json_payload, headers=headers)
+      return response
+
+  def _patch(self, path, payload):
+    try:
+      return self.__patch(path, payload)
+    except requests.ConnectionError as err:
+      self._log_posthog_connection_error(err)
+
+  def __patch(self, path, payload):
+    url = f"{self.api_base}{path}"
+    with bound_contextvars(method="patch", url=url):
+      json_payload = json.dumps(payload)
+      headers = self._get_headers()
+      response = requests.patch(url, data=json_payload, headers=headers)
+      return response
+
+  def _get_headers(self):
+    return {
+      "Content-Type": "application/json",
+      "Authorization": f"Bearer {self.api_key}"
+    }
+
+  def _check_status_ok(self, code):
+    return code == 200 or code == 201
+
+  def _map_single_response(self, method, path, response):
+    ret = None
+    if self._check_status_ok(response.status_code):
+        data = response.json()
+        self.logger.info("request successful", method=method, path=path, status_code=response.status_code, response=data)
+        ret = self._map_single_response_success(data)
+    else:
+        data = response.json()
+        self.logger.info("request failed", method=method, path=path, status_code=response.status_code, response=data)
+        ret = self._map_error_response(response.status_code, data)
+    return ret
+
+  def _map_list_response(self, method, path, response):
+    ret = None
+    if self._check_status_ok(response.status_code):
+        data = response.json()
+        self.logger.info("request successful", method=method, path=path, status_code=response.status_code, response=data)
+        ret = self._map_list_response_success(data)
+    else:
+        data = response.json()
+        self.logger.info("request failed", method=method, path=path, status_code=response.status_code, response=data)
+        ret = self._map_error_response(response.status_code, data)
+    return ret
+
+  def _map_error_response(self, code, data):
+    return {
+      "errors": [
+        {
+          "status": code,
+          "detail": data.get("detail"),
+          "code": data.get("code"),
+          "type": data.get("type")
+        }
+      ]
+    }
+
+  def _map_single_response_success(self, data):
+    return {
+      "data": data
+    }
+
+  def _map_list_response_success(self, data):
+    return {
+      "data": data.get("results"),
+      "pagination": {
+        "next": data.get("next"),
+        "previous": data.get("previous")
+      }
+    }
+
+  def _log_posthog_connection_error(self, error):
+    self.logger.error(f"Posthog connection error - {error}")
+    raise PosthogAPIClientError(f"Posthog connection error - {error}")

feature_gate-0.0.1/feature_gate/feature.py

@@ -0,0 +1,17 @@
+class Feature:
+  def __init__(self, name, key, description):
+    self._name = name
+    self._key = key
+    self._description = description
+
+  @property
+  def name(self):
+    return self._name
+
+  @property
+  def key(self):
+    return self._key
+
+  @property
+  def description(self):
+    return self._description

feature_gate-0.0.1/pyproject.toml

@@ -0,0 +1,25 @@
+
+[tool.poetry]
+name = "feature_gate"
+version = "0.0.1"
+description = "An extensible feature flagging library for Python"
+authors = ["Patrick Wiseman <patrick@deft.services>"]
+maintainers = ["Patrick Wiseman <patrick@deft.services>"]
+license = "MIT"
+readme = "README.md"
+homepage = "https://github.com/deftinc/feature_gate"
+repository = "https://github.com/deftinc/feature_gate"
+keywords = ["feature flags", "feature gate"]
+
+[tool.poetry.dependencies]
+python = ">= 3.10"
+structlog = "^24.1.0"
+requests = "^2.31.0"
+
+[tool.poetry.group.test.dependencies]
+pytest = "^8.0.0"
+pytest-mock = "^3.12.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"