dataflow-core 2.1.14__py3-none-any.whl → 2.1.15__py3-none-any.whl

dataflow/secrets_manager/providers/gcp_manager.py

@@ -0,0 +1,332 @@
+import os, base64, json, atexit
+from pathlib import Path
+from google.cloud import secretmanager
+from google.cloud.secretmanager_v1 import SecretManagerServiceClient
+from google.cloud.secretmanager_v1.types import Secret, SecretPayload
+from google.api_core.exceptions import (
+    AlreadyExists,
+    NotFound,
+    PermissionDenied,
+    Forbidden,
+    ResourceExhausted,
+    InvalidArgument,
+    FailedPrecondition
+)
+import json
+from ..interface import SecretManager
+from ...utils.exceptions import (
+    SecretNotFoundException,
+    SecretAlreadyExistsException,
+    SecretManagerAuthException,
+    SecretManagerServiceException
+)
+
+def _setup_gcp_credentials():
+    """Setup GCP credentials from base64 encoded JSON environment variable"""
+    
+    # Only run if GOOGLE_APPLICATION_CREDENTIALS is not already set
+    if os.getenv('GOOGLE_APPLICATION_CREDENTIALS'):
+        return
+    
+    # Get base64 encoded JSON credentials
+    encoded_json = os.getenv('GOOGLE_APPLICATION_CREDENTIALS_JSON')
+    
+    if encoded_json:
+        try:
+            # Decode base64 to JSON string
+            json_credentials = base64.b64decode(encoded_json).decode('utf-8')
+            
+            # Validate it's valid JSON
+            json.loads(json_credentials)  # Just to validate
+            
+            # Create credentials file in home directory
+            home_dir = Path.home()
+            credentials_dir = home_dir / '.gcp'
+            credentials_dir.mkdir(exist_ok=True)  # Create .gcp directory if it doesn't exist
+            
+            credentials_path = credentials_dir / 'credentials.json'
+            
+            # Write JSON string to credentials file
+            with open(credentials_path, 'w') as f:
+                f.write(json_credentials)
+            
+            # Set the standard Google environment variable that the SDK looks for
+            os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = str(credentials_path)
+            
+            # Clean up file on exit
+            atexit.register(lambda: credentials_path.unlink() if credentials_path.exists() else None)
+            
+            print(f"GCP credentials decoded and configured at {credentials_path}")
+            
+        except Exception as e:
+            print(f"Error setting up GCP credentials: {e}")
+
+
+class GCPSecretsManager(SecretManager):
+    """Google Cloud Platform Secrets Manager implementation."""
+
+    def __init__(self, project_id: str, region: str):
+        """Initialize the GCP Secret Manager client.
+        
+        Args:
+            project_id: The GCP project ID where secrets will be stored.
+            region: The GCP region where secrets will be stored.
+        """
+        self.project_id = project_id
+        self.region = region
+        try:
+            _setup_gcp_credentials()
+            self.client = secretmanager.SecretManagerServiceClient()
+        except PermissionDenied as e:
+            raise SecretManagerAuthException("initialize_gcp_client", original_error=str(e))
+        except Exception as e:
+            raise SecretManagerServiceException("initialize_gcp_client", original_error=str(e))
+    
+    def _get_secret_path(self, vault_path: str) -> str:
+        """Get the full secret path in GCP format.
+        
+        Args:
+            vault_path: The path/name of the secret.
+            
+        Returns:
+            The full path to the secret in GCP format.
+        """
+        return f"projects/{self.project_id}/secrets/{vault_path}"
+    
+    def _get_secret_version_path(self, vault_path: str, version: str = "latest") -> str:
+        """Get the full path to a specific secret version.
+        
+        Args:
+            vault_path: The path/name of the secret.
+            version: The version of the secret (default is "latest").
+            
+        Returns:
+            The full path to the secret version in GCP format.
+        """
+        return f"{self._get_secret_path(vault_path)}/versions/{version}"
+    
+    def create_secret(self, vault_path: str, secret_data: dict) -> str:
+        """Create a new secret.
+        
+        Args:
+            vault_path: The path/name of the secret.
+            region: The region where the secret will be stored.
+            secret_data: The data to store in the secret.
+            
+        Returns:
+            A success message.
+            
+        Raises:
+            SecretAlreadyExistsException: If the secret already exists.
+            SecretManagerAuthException: If there are permission issues.
+            SecretManagerServiceException: For other service errors.
+        """
+        try:
+            # Convert dictionary to JSON string before saving
+            secret_string = json.dumps(secret_data)
+            
+            # First create the secret
+            parent = f"projects/{self.project_id}"
+            secret = Secret(
+                replication={
+                    "user_managed": {
+                        "replicas": [
+                            {"location": self.region }
+                        ]
+                    }
+                }
+            )
+            
+            self.client.create_secret(
+                request={
+                    "parent": parent,
+                    "secret_id": vault_path,
+                    "secret": secret
+                }
+            )
+            
+            # Then add the secret version with the data
+            secret_path = self._get_secret_path(vault_path)
+            self.client.add_secret_version(
+                request={
+                    "parent": secret_path,
+                    "payload": {"data": secret_string.encode("UTF-8")}
+                }
+            )
+            
+            return "Secret created successfully"
+        except AlreadyExists as e:
+            raise SecretAlreadyExistsException("secret", vault_path, original_error=str(e))
+        except PermissionDenied as e:
+            raise SecretManagerAuthException("create_secret", original_error=str(e))
+        except Forbidden as e:
+            raise SecretManagerAuthException("create_secret", original_error=str(e))
+        except FailedPrecondition as e:
+            # Handle case where secret might be in recovery/deleted state
+            if "pending deletion" in str(e).lower() or "scheduled for deletion" in str(e).lower():
+                raise SecretAlreadyExistsException("secret", vault_path, original_error=str(e), is_scheduled_for_deletion=True)
+            else:
+                raise SecretManagerServiceException("create_secret", original_error=str(e))
+        except ResourceExhausted as e:
+            raise SecretManagerServiceException("create_secret", original_error=str(e))
+        except Exception as e:
+            raise SecretManagerServiceException("create_secret", original_error=str(e))
+    
+    def get_secret_by_key(self, vault_path: str) -> dict:
+        """Get a secret by its key.
+        
+        Args:
+            vault_path: The path/name of the secret.
+            
+        Returns:
+            The secret data as a dictionary.
+            
+        Raises:
+            SecretNotFoundException: If the secret doesn't exist.
+            SecretManagerAuthException: If there are permission issues.
+            SecretManagerServiceException: For other service errors.
+        """
+        try:
+            # Get the latest version of the secret
+            name = self._get_secret_version_path(vault_path)
+            response = self.client.access_secret_version(request={"name": name})
+            
+            # Decode the payload and convert JSON string back to dictionary
+            secret_string = response.payload.data.decode("UTF-8")
+            secret_data = json.loads(secret_string)
+            return secret_data
+        except NotFound as e:
+            raise SecretNotFoundException("secret", vault_path, original_error=str(e))
+        except PermissionDenied as e:
+            raise SecretManagerAuthException("get_secret", original_error=str(e))
+        except Forbidden as e:
+            raise SecretManagerAuthException("get_secret", original_error=str(e))
+        except InvalidArgument as e:
+            raise SecretManagerServiceException("get_secret", original_error=str(e))
+        except json.JSONDecodeError as e:
+            raise SecretManagerServiceException("get_secret", original_error=str(e))
+        except Exception as e:
+            raise SecretManagerServiceException("get_secret", original_error=str(e))
+    
+    def update_secret(self, vault_path: str, update_data: dict) -> str:
+        """Update an existing secret.
+        
+        Args:
+            vault_path: The path/name of the secret.
+            update_data: The data to update in the secret.
+            
+        Returns:
+            A success message.
+            
+        Raises:
+            SecretNotFoundException: If the secret doesn't exist.
+            SecretManagerAuthException: If there are permission issues.
+            SecretManagerServiceException: For other service errors.
+        """
+        try:
+            # Get current secret data
+            current_data = self.get_secret_by_key(vault_path)
+            
+            # Update with new data
+            current_data.update(update_data)
+            
+            # Convert updated dictionary to JSON string
+            updated_string = json.dumps(current_data)
+            
+            # Add a new version of the secret with updated data
+            secret_path = self._get_secret_path(vault_path)
+            self.client.add_secret_version(
+                request={
+                    "parent": secret_path,
+                    "payload": {"data": updated_string.encode("UTF-8")}
+                }
+            )
+            
+            return "Secret updated successfully"
+        except SecretNotFoundException:
+            raise
+        except PermissionDenied as e:
+            raise SecretManagerAuthException("update_secret", original_error=str(e))
+        except Forbidden as e:
+            raise SecretManagerAuthException("update_secret", original_error=str(e))
+        except NotFound as e:
+            raise SecretNotFoundException("secret", vault_path, original_error=str(e))
+        except InvalidArgument as e:
+            raise SecretManagerServiceException("update_secret", original_error=str(e))
+        except json.JSONDecodeError as e:
+            raise SecretManagerServiceException("update_secret", original_error=str(e))
+        except Exception as e:
+            raise SecretManagerServiceException("update_secret", original_error=str(e))
+    
+    def delete_secret(self, vault_path: str) -> str:
+        """Delete a secret.
+        
+        Args:
+            vault_path: The path/name of the secret.
+            
+        Returns:
+            A success message.
+            
+        Raises:
+            SecretNotFoundException: If the secret doesn't exist.
+            SecretManagerAuthException: If there are permission issues.
+            SecretManagerServiceException: For other service errors.
+        """
+        try:
+            # Get the full path to the secret
+            name = self._get_secret_path(vault_path)
+            
+            # For git-ssh secrets, destroy without recovery
+            if "git-ssh" in vault_path:
+                # Get all versions to destroy them permanently
+                versions = self.client.list_secret_versions(request={"parent": name})
+                for version in versions:
+                    if version.state == secretmanager.SecretVersion.State.ENABLED:
+                        version_name = f"{name}/versions/{version.name.split('/')[-1]}"
+                        self.client.destroy_secret_version(request={"name": version_name})
+                
+                # Delete the secret itself
+                self.client.delete_secret(request={"name": name})
+            else:
+                # For regular secrets, use the default 7-day recovery window
+                self.client.delete_secret(request={
+                    "name": name,
+                    # In GCP, the recovery window is configured at the service level, 
+                    # not per API call, so we don't specify it here
+                })
+            
+            return "Secret deleted successfully"
+        except NotFound as e:
+            raise SecretNotFoundException("secret", vault_path, original_error=str(e))
+        except PermissionDenied as e:
+            raise SecretManagerAuthException("delete_secret", original_error=str(e))
+        except Forbidden as e:
+            raise SecretManagerAuthException("delete_secret", original_error=str(e))
+        except InvalidArgument as e:
+            raise SecretManagerServiceException("delete_secret", original_error=str(e))
+        except Exception as e:
+            raise SecretManagerServiceException("delete_secret", original_error=str(e))
+    
+    def test_connection(self, vault_path: str) -> str:
+        """Test the connection to the secret manager by attempting to access a secret.
+        
+        Args:
+            vault_path: The path/name of the secret to test.
+            
+        Returns:
+            The status of the secret.
+            
+        Raises:
+            SecretNotFoundException: If the secret doesn't exist.
+            SecretManagerAuthException: If there are permission issues.
+            SecretManagerServiceException: For other service errors.
+        """
+        try:
+            secret = self.get_secret_by_key(vault_path)
+            return secret.get('status', 'Unknown')
+        except SecretNotFoundException:
+            raise
+        except (SecretManagerAuthException, SecretManagerServiceException):
+            raise
+        except Exception as e:
+            raise SecretManagerServiceException("test_connection", original_error=str(e))

dataflow/secrets_manager/service.py

@@ -117,27 +117,29 @@ class _BaseAccessor(ABC):
 # These classes implement the logic for building the vault path based on the context.
 # --------------------------------------------------------------------------
 class _RuntimeAccessor(_BaseAccessor):
-    def __init__(self, secret_manager: SecretManager, runtime_env: str, slug: str = None):
+    def __init__(self, secret_manager: SecretManager, org_id: str, runtime_env: str, slug: str = None):
         super().__init__(secret_manager)
+        self.org_id = org_id
         self.runtime_env = runtime_env
         self.slug = slug
 
     def _get_vault_path(self, secret_type: str, key: str) -> str:
         # Special case for git-ssh in runtime context
         if secret_type == "git-ssh":
-            return f"{self.runtime_env}-{secret_type}-{self.slug}"
+            return f"{self.org_id}-{self.runtime_env}-{secret_type}-{self.slug}"
 
         # Standard format for all other secret types
         context = self.slug if self.slug else "global"
-        return f"{self.runtime_env}-{context}-{secret_type}-{key}"
+        return f"{self.org_id}-{self.runtime_env}-{context}-{secret_type}-{key}"
 
 class _StudioAccessor(_BaseAccessor):
-    def __init__(self, secret_manager: SecretManager, user_name: str):
+    def __init__(self, secret_manager: SecretManager, org_id: str, user_name: str):
         super().__init__(secret_manager)
+        self.org_id = org_id
         self.user_name = user_name
 
     def _get_vault_path(self, secret_type: str, key: str) -> str:
-        return f"{self.user_name}-{secret_type}-{key}"
+        return f"{self.org_id}-{self.user_name}-{secret_type}-{key}"
 
 # --------------------------------------------------------------------------
 # PUBLIC INTERFACE CLASS
@@ -147,10 +149,10 @@ class SecretsService:
     def __init__(self, secret_manager: SecretManager):
         self._secret_manager = secret_manager
 
-    def runtime(self, env: str, slug: str = None) -> _RuntimeAccessor:
+    def runtime(self, org_id: int, env: str, slug: str = None) -> _RuntimeAccessor:
         """Sets the context to RUNTIME and returns the appropriate accessor."""
-        return _RuntimeAccessor(self._secret_manager, env, slug)
+        return _RuntimeAccessor(self._secret_manager, str(org_id), env, slug)
 
-    def studio(self, user: str) -> _StudioAccessor:
+    def studio(self, org_id: int, user: str) -> _StudioAccessor:
         """Sets the context to STUDIO and returns the appropriate accessor."""
-        return _StudioAccessor(self._secret_manager, user)
+        return _StudioAccessor(self._secret_manager, str(org_id), user)

dataflow/utils/get_current_user.py

@@ -1,37 +1,60 @@
-from fastapi import HTTPException, status
+from fastapi import HTTPException
 from sqlalchemy.orm import Session
-from dataflow.models import user as m_user  
-from dataflow.models import session as m_session
+from sqlalchemy import and_
+from dataflow.models import (
+    user as m_user,
+    session as m_session,
+    org_associations as m_org_associations,
+    role as m_role,
+    organization as m_organization
+)
 
 def get_user_from_session(session_id: str, db: Session):
     """
-    Retrieve a user based on session ID.
-    
-    Args:
-        session_id (str): The unique session identifier
-        db (Session): Database session
-        
-    Returns:
-        User: User object if found
-        
-    Raises:
-        HTTPException: If session is invalid or user not found
+    Retrieve user information based on the session ID.
     """
-    session_record = db.query(m_session.Session).filter(m_session.Session.session_id == session_id).first()
-    if not session_record:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid session")
+    user = (
+        db.query(
+            m_user.User,
+            m_org_associations.OrganizationUser.role_id,
+            m_role.Role.name,
+            m_role.Role.base_role,
+            m_org_associations.OrganizationUser.active_server_id,
+            m_org_associations.OrganizationUser.show_server_page,
+            m_org_associations.OrganizationUser.active_env_short_name,
+            m_org_associations.OrganizationUser.active_env_type,
+            m_org_associations.OrganizationUser.monthly_allocation,
+            m_organization.Organization.uid
+        )
+        .join(m_session.Session, m_session.Session.user_id == m_user.User.user_id)
+        .outerjoin(
+            m_org_associations.OrganizationUser,
+            and_(
+                m_org_associations.OrganizationUser.user_id == m_user.User.user_id,
+                m_org_associations.OrganizationUser.org_id == m_user.User.active_org_id
+            )
+        )
+        .outerjoin(m_role.Role, m_role.Role.id == m_org_associations.OrganizationUser.role_id)
+        .outerjoin(
+            m_organization.Organization,
+            m_organization.Organization.id == m_user.User.active_org_id  # join to Organization
+        )
+        .filter(m_session.Session.session_id == session_id)
+        .first()
+    )
 
-    user = db.query(m_user.User).filter(m_user.User.user_id == session_record.user_id).first()
     if not user:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="User not found")
-
-    base_role = user.role_details.base_role
-    role_id = user.role_details.id
-    role_name = user.role_details.name
-    user.base_role = base_role
-    user.role = role_name
-    user.role_id = role_id
-    
-    return user
+        raise HTTPException(status_code=401, detail="Invalid session")
 
+    user_obj, role_id, role_name, base_role, active_server_id, show_server_page, active_env_short_name, active_env_type, monthly_allocation, uid = user
+    user_obj.role_id = role_id
+    user_obj.role = role_name
+    user_obj.base_role = base_role
+    user_obj.current_server_id = active_server_id
+    user_obj.show_server_page = show_server_page
+    user_obj.active_env = active_env_short_name
+    user_obj.active_env_type = active_env_type
+    user_obj.monthly_allocation = monthly_allocation
+    user_obj.org_uid = str(uid)
 
+    return user_obj

{dataflow_core-2.1.14.dist-info → dataflow_core-2.1.15.dist-info}/METADATA

@@ -1,16 +1,19 @@
 Metadata-Version: 2.4
 Name: dataflow-core
-Version: 2.1.14
+Version: 2.1.15
 Summary: Dataflow core package
 Author: Dataflow
 Author-email: 
 Requires-Dist: sqlalchemy
+Requires-Dist: alembic
 Requires-Dist: boto3
 Requires-Dist: psycopg2-binary
 Requires-Dist: pymysql
 Requires-Dist: requests
 Requires-Dist: azure-identity
 Requires-Dist: azure-keyvault-secrets
+Requires-Dist: google-auth
+Requires-Dist: google-cloud-secret-manager
 Dynamic: author
 Dynamic: requires-dist
 Dynamic: summary

dataflow_core-2.1.15.dist-info/RECORD

@@ -0,0 +1,63 @@
+authenticator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+authenticator/dataflowairflowauthenticator.py,sha256=gEdCiL2yJQ7lYvAwbrjcAkccVMfehoMJldw9eU7cc2s,2243
+authenticator/dataflowhubauthenticator.py,sha256=0dt8-yeFtty1kq50qxBHafzwuWy8fG00QVnq6svH12c,12913
+authenticator/dataflowsupersetauthenticator.py,sha256=NkAmDaIc-ui-qEolu4xz_UY7P_2g8111hwNjPvAOW1Q,2839
+dataflow/__init__.py,sha256=WTRg8HMpMWSgxYJ9ZGVldx4k07fAbta3mBmZ1hG9mWE,30
+dataflow/configuration.py,sha256=7To6XwH1eESiYp39eqPcswXWwrdBUdPF6xN6WnazOF0,663
+dataflow/database_manager.py,sha256=tJHMuOZ9Muskrh9t4uLRlTuFU0VkHAzoHlGP5DORIC4,899
+dataflow/dataflow.py,sha256=EzeOMtMCqG0WJ0vld6ArKbKNFAmA9sbjBqVJ8sd2sQw,13026
+dataflow/db.py,sha256=73ojGqpCTRVTlPszD73Ozhjih_BI2KTHmazqxxL6iWk,3780
+dataflow/environment.py,sha256=7XiSojSIOnMOz5YVk-k6w1yQCKbBTTvUxv5cnn6cqJg,28830
+dataflow/models/__init__.py,sha256=FHus-b2oTgLSJ9H7dOCNJ14XpjTzHARqK_Vwh8VhCtM,1178
+dataflow/models/app_types.py,sha256=BNGtjwpQU6MSpBGp0pDzUI4uDZNqvE3_x33itIInasM,689
+dataflow/models/blacklist_library.py,sha256=B2oi3Z8GcR_glhLAyinFk0W8c9txXvm3uOER6dY-q7I,991
+dataflow/models/connection.py,sha256=c1zfwanuZRf6NvtA7lVU8z3taj_QX-bQSO1zbQzcBI0,1174
+dataflow/models/dataflow_zone.py,sha256=PHvZRpINTBN3NTxHYsSuTR-v2G2jZHF0zIIIrQVaBJw,762
+dataflow/models/environment.py,sha256=vkuFBRY9pZNMRXx3F4ZI6P2Nr-UNpqwzZkT-gM4NhyU,5097
+dataflow/models/environment_status.py,sha256=lvPDNUsUoTW9D97B07aKqJQHRKp4LvPM28pQDMPH1ac,536
+dataflow/models/git_ssh.py,sha256=xRkzK8lZ4Fa25zhE3Y9J78BiWv6xtd10YDBNf1XDKXE,797
+dataflow/models/org_associations.py,sha256=iih8xpbcWTsvOdBTs9LjW8kqPtFy7sBhIh7IU2pMGvo,1991
+dataflow/models/organization.py,sha256=hrvwQQuypM20eFX48QPmly1N0SM_pgML38BYA98vMb8,3446
+dataflow/models/pinned_projects.py,sha256=R_Euj98J2LzWrmedQ-A7mAluDyWes5VWt5dgqUs7EWc,639
+dataflow/models/pod_activity.py,sha256=4NQplUtckS4d2Uc-Iyi8PfgciblHiExbXo_VTMaukB8,751
+dataflow/models/pod_session_history.py,sha256=-O8DHtH1AtGLntJ1shI6eiciTJGL_vYvG3gfupvr0zY,778
+dataflow/models/project_details.py,sha256=C7b2VTOiF1BiUfgixIxdyZ2fMncCR7klQdTpF1rB6Wc,1342
+dataflow/models/recent_project_studio.py,sha256=5E5f55FXOq7vC76GNw-Bf8dUKmpFjwkkD-qthPGFKhM,836
+dataflow/models/recent_projects.py,sha256=OFd5MSRXVRHs9UbvUNoJBBnh9rgsJ0lwE23wm5_Hc5w,321
+dataflow/models/role.py,sha256=Kw9zqpG3R5nzwPXzg8MaoJGwDzN9r0rrOAKcVpsdkeY,1307
+dataflow/models/role_server.py,sha256=Qz9VqGSpVGvfLz9_lKITUfkiuR7pmVc8SIIfYrDPDso,547
+dataflow/models/role_zone.py,sha256=kQ9tUxxpwQ_VdbUNKqyacQ87SovsKKP5K6-EFrSTphk,962
+dataflow/models/server_config.py,sha256=FHO4y0Lm7wBcYDQYn1144duOkihIdRTLPIK0sfDEXIo,1768
+dataflow/models/session.py,sha256=c8TI6qXsM8utzp5vSQtAOXJSbgasnyu-a0qSAvA-rWs,459
+dataflow/models/team.py,sha256=u5VKOxi-0wGgxssIhXr1Ydn3X9IEAHNWxz029KaVm5g,780
+dataflow/models/user.py,sha256=ggJftOVLBEs_6fhn1_13Joe9aL32KMnJwHfBMzeMAOA,2959
+dataflow/models/user_team.py,sha256=vD6BsiMfx1iIMQiT8fpwhsQ8AGuPuBO83F22Cy7j-nU,524
+dataflow/models/variables.py,sha256=qCyiVbzC3Wd2onLx-eCY36VWiVytxxWvYld6_3ki5H8,1572
+dataflow/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataflow/schemas/connection.py,sha256=ut2sqz06yOjmFKzHry92FEt7DN09Bj30GYse35__Cuw,2467
+dataflow/schemas/git_ssh.py,sha256=N1O7HM6ZbygIBZn2rKvNR0e7IM3ZJMAH6aJtjaghDr0,1283
+dataflow/schemas/secret.py,sha256=wMSCn6zoBHS-R4NoKwljq2JUad8p9JY542UNJFa86X8,1183
+dataflow/scripts/clone_environment.sh,sha256=Qy0GylsA3kUVUL_L1MirxIWujOFhT1tikKqXNtCTWd4,506
+dataflow/scripts/create_environment.sh,sha256=3FHgNplJuEZvyTsLqlCJNX9oyfXgsfqn80VZk2xtvso,828
+dataflow/scripts/update_environment.sh,sha256=2dtn2xlNi6frpig-sqlGE1_IKRbbkqYOCpf_qyMKKII,992
+dataflow/secrets_manager/__init__.py,sha256=idGqIDtYl0De2WIK9Obl-N7SDPSYtVM0D-wXfZjCiy4,559
+dataflow/secrets_manager/factory.py,sha256=LblshkGG9q2C3RHYp0QykianUtpOOQz7sBdlerutyWY,2479
+dataflow/secrets_manager/interface.py,sha256=HhrKpQrprWIbDsVfU_qc59OXmSIuHXv106OXv6-Epqc,506
+dataflow/secrets_manager/service.py,sha256=A4PgiSS1bzlzXPi_GvsiepChULqAa5yONGkaU-d5MLM,7419
+dataflow/secrets_manager/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataflow/secrets_manager/providers/aws_manager.py,sha256=16peXyKeuAjv2RVTMUjrzArPYENK9Zu7jREWVgMfScA,8671
+dataflow/secrets_manager/providers/azure_manager.py,sha256=sWOz-7ALnLt6vyM3lt14GBpzpmDnlH3hkdqtuApqkgU,9430
+dataflow/secrets_manager/providers/gcp_manager.py,sha256=AJgotHZRQraxtmfJX1Z8u2Gcr7KJLRJTN_qbth3A5Xk,13738
+dataflow/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataflow/utils/exceptions.py,sha256=8GRFoYZ5dPGQckVm2znaHpPi0ZAs69fK-RGKukEsapk,4432
+dataflow/utils/get_current_user.py,sha256=iPyUpEpuxitdmFwvaPiRWIlII8JaaGoxUhQcmNWi0vI,2319
+dataflow/utils/logger.py,sha256=7BFrOq5Oiqn8P4XZbgJzMP5O07d2fpdECbbfsjrUuHw,1213
+dfmigration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dfmigration/env.py,sha256=w_3Kzr3LJCU5l1zBGsNcoNGZyR8fZEtMRsxE-cEqfHQ,1110
+dfmigration/versions/001_initial_baseline_migration.py,sha256=lxjs7LZLs9-c7FQj7t7t49EOfLPPHMLI6iNp0PIBMRA,299
+dfmigration/versions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataflow_core-2.1.15.dist-info/METADATA,sha256=Urk3FJfV79VaX794Lgc-q1d-2JvOhUQnWGzwmElyUpQ,463
+dataflow_core-2.1.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dataflow_core-2.1.15.dist-info/entry_points.txt,sha256=ppj_EIbYrJJwCPg1kfdsZk5q1N-Ejfis1neYrnjhO8o,117
+dataflow_core-2.1.15.dist-info/top_level.txt,sha256=-gGoIBh-bUMtzOdna2jsDOdkE2CRu3w3aA7yEFCmNAI,35
+dataflow_core-2.1.15.dist-info/RECORD,,

{dataflow_core-2.1.14.dist-info → dataflow_core-2.1.15.dist-info}/top_level.txt

@@ -1,2 +1,3 @@
 authenticator
 dataflow
+dfmigration

dfmigration/env.py

@@ -0,0 +1,45 @@
+from sqlalchemy import engine_from_config, pool
+from alembic import context
+import os
+
+config = context.config
+target_metadata = None
+
+def get_url():
+    return os.getenv('DATABASE_URL')
+
+def run_migrations_offline() -> None:
+    url = get_url()
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+def run_migrations_online() -> None:
+    configuration = config.get_section(config.config_ini_section) or {}
+    configuration['sqlalchemy.url'] = get_url()
+    
+    connectable = engine_from_config(
+        configuration,
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection, 
+            target_metadata=target_metadata
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

dfmigration/versions/001_initial_baseline_migration.py

@@ -0,0 +1,20 @@
+"""Initial baseline migration
+
+Revision ID: 001
+Revises: None
+Create Date: 2025-09-10 15:00:00.000000
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+revision = '001'
+down_revision = None
+branch_labels = None
+depends_on = None
+
+def upgrade() -> None:
+    pass
+
+def downgrade() -> None:
+    pass

dataflow/models/user_environment.py

@@ -1,16 +0,0 @@
-from sqlalchemy import Column, Integer, String, DateTime
-from sqlalchemy.sql.schema import ForeignKey
-from sqlalchemy.sql.expression import func
-from dataflow.db import Base
-
-class UserEnvironment(Base):
-    """
-    Table USER_ENVIRONMENT
-    """
-
-    __tablename__ = 'USER_ENVIRONMENT'
-
-    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
-    user_id = Column(Integer, ForeignKey('USER.user_id', ondelete="CASCADE"), nullable=False)
-    env_name = Column(String)
-    timestamp = Column(DateTime, server_default=func.now(), onupdate=func.now())