mind-castle 0.1.1__tar.gz

mind_castle-0.1.1/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: mind-castle
+Version: 0.1.1
+Summary: A universal secrets manager
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: boto3>=1.35.38
+Requires-Dist: sqlalchemy<3.0.0,>=2.0.0
+
+# mind-castle
+A universal secret store

mind_castle-0.1.1/README.md

@@ -0,0 +1,2 @@
+# mind-castle
+A universal secret store

mind_castle-0.1.1/mind_castle/secret_store.py

@@ -0,0 +1,20 @@
+from typing import Optional
+import uuid
+
+
+class SecretStore():
+    '''This is an abstract class that defines the interface for a secret store.'''
+
+    def get_secret(self, key: str, default: str = None) -> Optional[str]:
+        raise NotImplementedError()
+
+    def put_secret(self, value: str) -> dict:
+        raise NotImplementedError()
+
+    def get_secret_key(self) -> str:
+        '''
+        Generates a key based on this machine's hardware and the time.
+        https://docs.python.org/3/library/uuid.html#uuid.uuid1
+        '''
+
+        return str(uuid.uuid1())

mind_castle-0.1.1/mind_castle/secret_stores.py

@@ -0,0 +1,122 @@
+import json
+import os
+import boto3
+from enum import Enum
+from .secret_store import SecretStore
+from typing import Optional
+
+
+# If you add a secret store implementation here, make sure to add it to
+# the SecretStoreType enum and TYPE_STORE_MAP dictionary at the bottom of this file
+
+
+class MemorySecretStore(SecretStore):
+    '''
+    An in-memory secret store.
+    This is not persistent and will be lost when the application is restarted.
+    Use only for testing or development.
+    '''
+
+    store_type = "mem"
+
+    def __init__(self):
+        self.secrets = {}
+
+    def get_secret(self, key: str, default: str = None) -> Optional[str]:
+        return self.secrets.get(key, default)
+
+    def put_secret(self, value: str) -> dict:
+        key = self.get_secret_key()
+        self.secrets[key] = value
+        return {"secret_type": self.store_type, "key": key}
+
+
+class JsonSecretStore(SecretStore):
+    store_type = "json"
+    filename = "secrets.json"
+
+    def __init__(self):
+        if not os.path.exists(self.filename):
+            with open(self.filename, "w") as f:
+                f.write("{}")
+
+    def get_secret(self, key: str, default: str = None) -> Optional[str]:
+        with open(self.filename, "r") as f:
+            secrets = json.load(f)
+        return secrets.get(key, default)
+
+    def put_secret(self, value: str) -> dict:
+        key = self.get_secret_key()
+        with open(self.filename, "r") as f:
+            secrets = json.load(f)
+            secrets[key] = value
+
+        with open(self.filename, "w") as f:
+            json.dump(secrets, f)
+        return {"secret_type": self.store_type, "key": key}
+
+
+class AWSSecretsManagerSecretStore(SecretStore):
+    '''
+    Uses AWS Secrets Manager to store secrets.
+    This assumes you have credentials in the environment or in the default AWS credentials file.
+    '''
+    store_type = "awssecretsmanager"
+
+    def __init__(self):
+        # TODO: Use this region param as a test for how to pass args to a secret store init
+        self.client = boto3.client('secretsmanager', region_name='us-east-2')
+
+    def get_secret(self, key: str, default: str = None) -> Optional[str]:
+        response = self.client.get_secret_value(SecretId=key)
+        return response.get("SecretString", default)
+
+    def put_secret(self, value: str) -> dict:
+        key = self.get_secret_key()
+        # Response is always a success. This throws an exception if it fails
+        response = self.client.create_secret(
+            Name=key,
+            ClientRequestToken=key,
+            # Description='string',
+            # KmsKeyId='string',
+            # SecretBinary=b'bytes',
+            SecretString=value,
+            # Tags=[
+            #     {
+            #         'Key': 'string',
+            #         'Value': 'string'
+            #     },
+            # ],
+            # AddReplicaRegions=[
+            #     {
+            #         'Region': 'string',
+            #         'KmsKeyId': 'string'
+            #     },
+            # ],
+            # ForceOverwriteReplicaSecret=True|False
+        )
+        return {"secret_type": self.store_type, "key": key, "arn": response.get("ARN")}
+
+
+class SecretStoreType(str, Enum):
+    '''List of supported secret store types'''
+    MEMORY = MemorySecretStore.store_type
+    JSON = JsonSecretStore.store_type
+    AWS_SECRETS_MANAGER = AWSSecretsManagerSecretStore.store_type
+
+
+# Map of secret store types to their implementations
+TYPE_STORE_MAP = {
+    SecretStoreType.MEMORY: MemorySecretStore,
+    SecretStoreType.JSON: JsonSecretStore,
+    SecretStoreType.AWS_SECRETS_MANAGER: AWSSecretsManagerSecretStore
+}
+
+
+def get_secret_store(secret_type: SecretStoreType) -> SecretStore:
+    '''Instantiates and returns a SecretStore implementation with the given type.'''
+
+    store_class = TYPE_STORE_MAP.get(secret_type)
+    if store_class is None:
+        raise ValueError(f"Unknown secret store type '{secret_type}'")
+    return store_class()

mind_castle-0.1.1/mind_castle/secret_type.py

@@ -0,0 +1,50 @@
+import logging
+import sqlalchemy.types as types
+import json
+
+from .secret_stores import get_secret_store, SecretStoreType
+
+
+logger = logging.getLogger(__name__)
+logger.level = logging.DEBUG
+
+
+class SecretData(types.TypeDecorator):
+    '''A sqlalchemy field type that stores data in a secret store.'''
+
+    impl = types.JSON  # The base data type for this field
+    cache_ok = True
+
+    def __init__(self, store_type: SecretStoreType, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Get an implementation from the store factory
+        # based on the given store_type
+        self.secret_type = store_type
+        self.secret_store = get_secret_store(store_type)
+
+    def process_bind_param(self, value, dialect):
+        logger.debug(f"Storing {value} of type {type(value)} as a secret.")
+        # This might not be a dict or list, but let's json dump everything to be consistent
+        stringValue = json.dumps(value, sort_keys=True)
+
+        store_params = self.secret_store.put_secret(stringValue)
+        logger.debug(f"Stored {stringValue} as {store_params}")
+        return store_params
+
+    def process_result_value(self, value, dialect):
+        if value == {}:
+            return {}
+        logger.debug(f"Restoring {value} from a secret.")
+        secret_type = value.get("secret_type")
+        key = value.get("key")
+        if secret_type is None:
+            raise ValueError(f"Secret data is missing secret_type: {value}")
+
+        # We can't assume the secret type here is the same as 'self.secret_type'
+        # because the user may have been using a different secret store type previously
+        store = get_secret_store(secret_type) if secret_type != self.secret_type else self.secret_store
+        result = store.get_secret(key)
+        logger.debug(f"Restored {result} from key {key}")
+        if result is None:
+            return {}
+        return json.loads(result)

mind_castle-0.1.1/mind_castle.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: mind-castle
+Version: 0.1.1
+Summary: A universal secrets manager
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: boto3>=1.35.38
+Requires-Dist: sqlalchemy<3.0.0,>=2.0.0
+
+# mind-castle
+A universal secret store

mind_castle-0.1.1/mind_castle.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+mind_castle/__init__.py
+mind_castle/secret_store.py
+mind_castle/secret_stores.py
+mind_castle/secret_type.py
+mind_castle.egg-info/PKG-INFO
+mind_castle.egg-info/SOURCES.txt
+mind_castle.egg-info/dependency_links.txt
+mind_castle.egg-info/requires.txt
+mind_castle.egg-info/top_level.txt
+tests/test_memory.py

mind_castle-0.1.1/mind_castle.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mind_castle-0.1.1/mind_castle.egg-info/requires.txt

@@ -0,0 +1,2 @@
+boto3>=1.35.38
+sqlalchemy<3.0.0,>=2.0.0

mind_castle-0.1.1/mind_castle.egg-info/top_level.txt

@@ -0,0 +1 @@
+mind_castle

mind_castle-0.1.1/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "mind-castle"
+version = "0.1.1"
+description = "A universal secrets manager"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "boto3>=1.35.38",
+    "sqlalchemy>=2.0.0,<3.0.0",
+]
+
+[tool.pytest.ini_options]
+pythonpath = [
+  "."
+]
+
+[tool.uv]
+dev-dependencies = [
+    "pytest>=8.3.3",
+]
+package = true

mind_castle-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mind_castle-0.1.1/tests/test_memory.py

@@ -0,0 +1,15 @@
+from memory_secret_store import MemorySecretStore
+
+
+def test_put_secret():
+    secret_store = MemorySecretStore()
+    secret_store.put_secret("some_secret_key", "some_secret_value")
+
+    assert secret_store.secrets["some_secret_key"] == "some_secret_value"
+
+
+def test_get_secret():
+    secret_store = MemorySecretStore()
+    secret_store.put_secret("some_secret_key", "some_secret_value")
+
+    assert secret_store.get_secret("some_secret_key") == "some_secret_value"