dataflow-core 2.0.7__py3-none-any.whl → 2.0.9__py3-none-any.whl

dataflow/dataflow.py

@@ -1,5 +1,6 @@
-import os, requests
+import os, requests, shutil, subprocess, datetime
 from .models.database import DatabaseManager
+from .models.environment import JobLogs
 from sqlalchemy.inspection import inspect
 from .utils.aws_secrets_manager import SecretsManagerClient
 import json, asyncio, pkg_resources
@@ -8,7 +9,7 @@ from authenticator.package.configuration import ConfigurationManager
 
 class Dataflow:
     def __init__(self):
-        self.secrets_manager = SecretsManagerClient('us-east-1')
+        self.secrets_manager = SecretsManagerClient()
 
     def auth(self, session_id: str):
         """Retrieve user information from the auth API."""
@@ -85,43 +86,4 @@ class Dataflow:
             return next(connection_instance.get_session())
         
         except Exception as e:
-            return None
-        
-    async def create_env(self, env_name, py_version, py_requirements, status, env_version=None):
-        """
-        Creates a conda environment at the specified path and installs libraries in one command.
-        """
-        config = ConfigurationManager('/dataflow/app/config/dataflow.cfg')
-        status = status.lower()
-        if status == "published":
-            env_base_path = config.get_config_value('paths', 'published_env_path')
-            conda_env_path = os.path.join(env_base_path, env_name)
-        else:
-            env_base_path = config.get_config_value('paths', 'drafts_env_path')
-            conda_env_path = os.path.join(env_base_path, env_name, f"{env_name}_v{env_version}")
-        try:
-            if not os.path.exists(conda_env_path):
-                os.makedirs(conda_env_path, exist_ok=True)
-
-            py_requirements = ",".join(py_requirements) 
-
-            script_path = pkg_resources.resource_filename('dataflow', 'scripts/create_environment.sh')
-    
-            # Make the script executable
-            os.chmod(script_path, 0o755)
-            
-            # Prepare command with arguments
-            command = ["bash", script_path, py_requirements, conda_env_path, py_version]
-
-            process = await asyncio.create_subprocess_exec(
-                *command, 
-                stdout=asyncio.subprocess.PIPE, 
-                stderr=asyncio.subprocess.PIPE
-            )
-            
-            return process
-        except OSError as e:
-            print(f"OS error while creating {conda_env_path}: {e}")
-        except Exception as e:
-            print(f"Unexpected error while creating {conda_env_path}: {e}")
-            return {"error": str(e)}
+            return None

dataflow/environment.py

@@ -0,0 +1,459 @@
+import os, shutil, subprocess, datetime
+from .models.database import DatabaseManager
+from .models.environment import JobLogs, Environment
+import json, asyncio, pkg_resources
+from sqlalchemy.orm import Session
+from authenticator.package.configuration import ConfigurationManager
+
+class EnvironmentManager:
+    def __init__(self):
+        """Initialize the EnvironmentManager"""
+        self.config = ConfigurationManager('/dataflow/app/config/dataflow.cfg')
+        self.published_env_path = self.config.get_config_value('paths', 'published_env_path')
+        self.draft_env_path = self.config.get_config_value('paths', 'drafts_env_path')
+        self.env_logs_path = self.config.get_config_value('paths', 'env_logs_path')
+    
+    async def create_env(self, env_name, py_version, py_requirements, status, base_env_id, env_version=None, user_name=None, db:Session=None):
+        """
+        Creates a conda environment with specified Python version and packages.
+        
+        Args:
+            env_name (str): Name of the environment
+            py_version (str): Python version to use
+            py_requirements (list): List of packages to install
+            status (str): Environment status ('draft' or 'published')
+            env_version (str): Version of the environment (for draft environments)
+            user_name (str): Username who initiated the creation
+            db (Session): Database session (optional, will create if None)
+            
+        Returns:
+            str: Build status ('success' or 'fail')
+        """
+        # Set up logging
+        log_file_location = None
+        if db:
+            log_file_location = self._setup_logging(env_name, env_version, user_name, db)
+
+        if status == "published":
+            return await self._execute_env_operation(
+                env_name=env_name,
+                py_version=py_version,
+                py_requirements=py_requirements,
+                status="published",
+                env_version=None,
+                mode="create"
+            )
+        elif status == "draft":
+            # Build the environment
+            build_status = await self._execute_env_operation(
+                env_name=env_name,
+                py_version=py_version,
+                py_requirements=py_requirements,
+                status=status,
+                env_version=env_version,
+                log_file_location=log_file_location,
+                mode="create"
+            )
+            
+            # Update job log status if db was provided
+            if db and log_file_location:
+                log_file_name = os.path.basename(log_file_location)
+                await self._update_job_status(log_file_name, build_status, log_file_location, db)
+                updated_py_requirements = self.update_library_versions(py_requirements, os.path.join(self.draft_env_path, env_name, f"{env_name}_v{env_version}"))
+                self.update_environment_db(env_name, env_version, updated_py_requirements, base_env_id, py_version, db)
+
+            return build_status
+        
+        else:
+            raise ValueError("Invalid status. Use 'draft' or 'published'.")
+    
+    async def clone_env(self, source_path, target_env_name, libraries, py_version, user_name=None, db: Session=None):
+        """
+        Clones an existing conda environment.
+        
+        Args:
+            source_path (str): Path to source environment
+            target_name (str): Name for the target environment
+            status (str): Environment status ('draft' or 'published')
+            env_version (str): Version of the environment (for draft environments)
+            user_name (str): Username who initiated the clone
+            db (Session): Database session (optional, will create if None)
+            
+        Returns:
+            str: Build status ('success' or 'fail')
+        """
+        # Set up logging
+        log_file_location = None
+        if db:
+            log_file_location = self._setup_logging(target_env_name, "1", user_name, db)
+        
+        # Perform the clone operation
+        clone_status = await self._execute_env_operation(
+            env_name=target_env_name,
+            source_path=source_path,
+            status="draft",
+            env_version="1",
+            log_file_location=log_file_location,
+            mode="clone"
+        )
+        
+        # Update job log status if db was provided
+        if db and log_file_location:
+            log_file_name = os.path.basename(log_file_location)
+            await self._update_job_status(log_file_name, clone_status, log_file_location, db)
+            self.update_environment_db(env_short_name=target_env_name, version="1", libraries=libraries, base_env_id=None, py_version=py_version, db=db)
+            
+        return clone_status
+    
+    async def create_published_env(self, env_name, py_version, py_requirements):
+        """
+        Creates a published conda environment.
+        
+        Args:
+            env_name (str): Name of the environment
+            py_version (str): Python version to use
+            py_requirements (list): List of packages to install
+            status (str): Environment status ('draft' or 'published')
+            env_version (str): Version of the environment (for draft environments)
+            user_name (str): Username who initiated the creation
+            
+        Returns:
+            str: Build status ('success' or 'fail')
+        """
+        return self._execute_env_operation(
+            env_name=env_name,
+            py_version=py_version,
+            py_requirements=py_requirements,
+            status="published",
+            env_version=None,
+            mode="create"
+        )
+        
+    async def _execute_env_operation(self, env_name: str, status: str, mode: str, env_version: str = None, py_version: str = None, py_requirements=None, source_path=None, log_file_location=None):
+        """
+        Executes environment operations (create or clone).
+        
+        Args:
+            env_name (str): Name of the environment
+            status (str): Environment status ('draft' or 'published')
+            mode (str): Operation mode ('create' or 'clone')
+            env_version (str): Version of the environment (for draft environments)
+            py_version (str): Python version to use (for create mode)
+            py_requirements (list): List of packages to install (for create mode)
+            source_path (str): Path to source environment (for clone mode)
+            log_file_location (str): Path to log file
+            
+        Returns:
+            str: Build status ('success' or 'fail')
+        """
+        status = status.lower()
+        if status == "published":
+            env_base_path = self.config.get_config_value('paths', 'published_env_path')
+            conda_env_path = os.path.join(env_base_path, env_name)
+        else:
+            env_base_path = self.config.get_config_value('paths', 'drafts_env_path')
+            conda_env_path = os.path.join(env_base_path, env_name, f"{env_name}_v{env_version}")
+
+        try:
+            if not os.path.exists(conda_env_path):
+                os.makedirs(conda_env_path, exist_ok=True)
+
+            if mode == "create":
+                # Convert requirements list to comma-separated string
+                if isinstance(py_requirements, list):
+                    py_requirements = ",".join(py_requirements)
+                
+                create_env_script_path = pkg_resources.resource_filename('dataflow', 'scripts/create_environment.sh')
+                command = ["bash", create_env_script_path, py_requirements, conda_env_path, py_version]
+                
+            elif mode == "clone":
+                clone_env_script_path = pkg_resources.resource_filename('dataflow', 'scripts/clone_environment.sh')
+                command = ["bash", clone_env_script_path, source_path, conda_env_path]
+                
+            else:
+                raise ValueError("Invalid mode. Use 'create' or 'clone'.")
+
+            process = await asyncio.create_subprocess_exec(
+                *command, 
+                stdout=asyncio.subprocess.PIPE, 
+                stderr=asyncio.subprocess.PIPE
+            )
+
+            if not log_file_location:
+                return process
+
+            with open(log_file_location, "a") as log_file:
+                success_detected = False
+                try:
+                    while True:
+                        line = await process.stdout.readline()
+                        if not line:
+                            break
+                            
+                        line = line.decode()
+                        message = {
+                            "timestamp": self.format_timestamp(),
+                            "type": "log",  
+                            "content": line.strip()
+                        }
+                        log_file.write(json.dumps(message) + "\n")
+                        log_file.flush()
+
+                        if "environment creation successful" in line.lower():
+                            success_detected = True
+                            
+                    await process.wait()  # Ensure process is complete
+                    
+                    if process.returncode != 0:
+                        error_message = await process.stderr.read()
+                        error_message = error_message.decode().strip()
+                        error_message_dict = {
+                            "timestamp": self.format_timestamp(),
+                            "type": "error",
+                            "content": error_message
+                        }
+                        log_file.write(json.dumps(error_message_dict) + "\n")
+
+                    final_build_status = "fail" if process.returncode != 0 else "success"
+
+                except asyncio.CancelledError:
+                    process.kill()
+                    msg_content = "Environment operation cancelled due to request cancellation."
+                    cancellation_message = {
+                        "timestamp": self.format_timestamp(),
+                        "type": "error",
+                        "content": msg_content
+                    }
+                    log_file.write(json.dumps(cancellation_message) + "\n")
+                    final_build_status = "fail"
+                
+                finally:
+                    if final_build_status == "success" and status == "draft":
+                        symlink_path = os.path.join(env_base_path, env_name, "default")
+                        self.update_symlink(symlink_path, conda_env_path)
+                    elif final_build_status != "success":
+                        if os.path.exists(conda_env_path):
+                            shutil.rmtree(conda_env_path)
+                
+            return final_build_status
+        
+        except OSError as e:
+            print(f"OS error while operating on {conda_env_path}: {e}")
+            return "fail"
+        except subprocess.CalledProcessError as e:
+            print(f"Subprocess error during environment operation: {e}")
+            return "fail"
+        except Exception as e:
+            print(f"Unexpected error during environment operation for {env_name}: {e}")
+            return "fail"
+    
+    def _setup_logging(self, env_name: str, env_version: str, user_name: str, db: Session):
+        """
+        Sets up logging for environment operations.
+        
+        Args:
+            env_name (str): Name of the environment
+            env_version (str): Version of the environment
+            user_name (str): Username who initiated the operation
+            db (Session): Database session
+            
+        Returns:
+            str: Path to the log file
+        """
+        versioned_name = f"{env_name}_v{env_version}"
+        log_file_name = f"envlog_{versioned_name}.log"
+        log_file_dir = self.config.get_config_value('paths', 'env_logs_path')
+        os.makedirs(log_file_dir, exist_ok=True)
+        log_file_location = os.path.join(log_file_dir, log_file_name)
+        
+        # Clear log file if it exists
+        if os.path.exists(log_file_location):
+            open(log_file_location, "w").close()
+        
+        # Create job entry
+        self.create_job_entry(user_name, db, log_file_name, log_file_location)
+        
+        return log_file_location
+    
+    async def _update_job_status(self, log_file_name: str, build_status: str, log_file_location: str, db: Session):
+        """
+        Updates job status with retry logic.
+        
+        Args:
+            db (Session): Database session
+            log_file_name (str): Name of the log file
+            build_status (str): Build status ('success' or 'fail') 
+            log_file_location (str): Path to the log file
+        """
+        attempts = 3
+        retry_delay = 3
+        
+        while attempts > 0:
+            try:
+                self.update_job_log(db, log_file_name, build_status)
+                break
+            except Exception as e:
+                attempts -= 1
+                
+                with open(log_file_location, "a") as log_file:
+                    msg_content = "Failed to commit job completion time to database."
+                    error_message = {
+                        "timestamp": self.format_timestamp(),
+                        "type": "error",
+                        "content": msg_content
+                    }
+                    log_file.write(json.dumps(error_message) + "\n")
+                
+                if attempts > 0:
+                    await asyncio.sleep(retry_delay)
+                else:
+                    print(f"Failed to update job log after multiple attempts: {e}")
+    
+    def create_job_entry(self, user_name: str, db: Session, log_file_name: str, log_file_location: str):
+        """
+        Creates or updates a job entry for environment tracking.
+        
+        Args:
+            user_name (str): The user who initiated the job
+            db (Session): Database session
+            log_file_name (str): Log file name
+            log_file_location (str): Log file path
+            
+        Returns:
+            JobLogs: The created or updated job entry
+        """
+        job = db.query(JobLogs).filter(JobLogs.log_file_name == log_file_name).first()
+
+        if job:
+            if job.status == "success":
+                raise ValueError(f"Job with log_file_name '{log_file_name}' already completed successfully.")
+            if job.status == "fail":
+                job.created_at = datetime.datetime.now() 
+                job.status = "in_progress"
+        else:
+            job = JobLogs(
+                created_at=datetime.datetime.now(),
+                log_file_name=log_file_name,
+                log_file_location=log_file_location,
+                created_by=user_name,
+                status="in_progress"
+            )
+            db.add(job)
+
+        db.commit()
+        return job
+    
+    def update_job_log(self, db, log_file_name, final_build_status):
+        """
+        Updates the JobLogs table with completion time and status.
+        
+        Args:
+            db (Session): Database session
+            log_file_name (str): Name of the log file
+            final_build_status (str): Final status of the build ('success' or 'fail')
+        """
+        try:
+            job_record = db.query(JobLogs).filter(JobLogs.log_file_name == log_file_name).first()
+            if job_record:
+                job_record.completed_at = datetime.datetime.now()
+                job_record.status = final_build_status
+                db.commit()
+            else:
+                raise ValueError(f"No job log found for file: {log_file_name}")
+        except Exception as e:
+            db.rollback()
+            raise
+            
+    def update_symlink(self, symlink_path, conda_env_path):
+        """
+        Creates or updates the symlink to point to the default version.
+        """
+        symlink_dir = os.path.dirname(symlink_path)
+        if not os.path.exists(symlink_dir):
+            os.makedirs(symlink_dir, exist_ok=True)
+
+        # If symlink exists, remove it before updating
+        if os.path.islink(symlink_path):
+            os.remove(symlink_path)
+
+        subprocess.run(["ln", "-sf", conda_env_path, symlink_path], check=True)
+
+    def format_timestamp(self):
+        """
+        Generates a formatted timestamp string representing the current date and time.
+
+        Returns:
+            str: A string representing the current date and time in the specified format.
+        """
+        return datetime.datetime.now().strftime("%b %d  %I:%M:%S %p")
+    
+    def update_environment_db(self, env_short_name, version, libraries, base_env_id, py_version, db: Session):
+        """
+        Updates the environment table with the new version and libraries.
+        """
+        try:
+            if isinstance(libraries, list):
+                libraries = ", ".join(libraries)
+            current_env = db.query(Environment).filter(Environment.short_name == env_short_name).first()
+            status = "Draft" if current_env and current_env.status == "Saved" else current_env.status
+            db.query(Environment).filter(Environment.short_name == env_short_name).update({"version": version, "py_requirements": libraries,"base_image_id": base_env_id,"py_version": py_version,"status": status})
+            db.commit()
+
+        except Exception as e:
+            db.rollback()
+            raise
+
+    
+    def update_library_versions(self, libraries: list, conda_env_path: str) -> list:
+        """
+        Updates libraries without version specifications by getting their actual installed versions.
+        
+        Args:
+            libraries (list): List of library requirements, some may not have version specs.
+            conda_env_path (str): Path to the conda environment where libraries are installed.
+            
+        Returns:
+            list: Updated list of libraries with version specifications.
+        """
+        try:
+            pip_freeze_cmd = f"{conda_env_path}/bin/pip freeze"
+            result = subprocess.run(
+                pip_freeze_cmd, 
+                shell=True, 
+                capture_output=True, 
+                text=True,
+                check=True
+            )
+            
+            installed_versions = {}
+            for line in result.stdout.splitlines():
+                if "==" in line:
+                    lib_name, version = line.split("==", 1)
+                    installed_versions[lib_name.lower()] = version
+            
+            # Update libraries without version specs
+            updated_libraries = []
+            for lib in libraries:
+                # Skip libraries that are python version specifications
+                if lib.lower().startswith("python=="):
+                    continue
+                    
+                if "==" not in lib:
+                    lib_name = lib.strip()
+                    lib_name_lower = lib_name.lower()
+                    
+                    if lib_name_lower in installed_versions:
+                        updated_libraries.append(f"{lib_name}=={installed_versions[lib_name_lower]}")
+                    else:
+                        updated_libraries.append(lib)
+                else:
+                    updated_libraries.append(lib)
+                    
+            return updated_libraries
+            
+        except subprocess.CalledProcessError as e:
+            print(f"Error running pip freeze: {e.stderr}")
+            return libraries
+        except Exception as e:
+            print(f"Error updating library versions: {str(e)}")
+            return libraries

dataflow/models/environment.py

@@ -0,0 +1,64 @@
+from sqlalchemy import Column, Integer, String, Boolean, Text, ForeignKey, DateTime
+from sqlalchemy.orm import relationship, declarative_base
+from sqlalchemy.sql import func
+from datetime import datetime
+
+Base = declarative_base()
+
+class EnvironmentAttributes(Base):
+    """
+    Shared columns between Environment and ArchivedEnvironment.
+    """
+    __abstract__ = True 
+
+    name = Column(String)
+    url = Column(String)
+    enabled = Column(Boolean, default=True)
+    version = Column(String, default=0)
+    is_latest = Column(Boolean, default=True)
+    base_image_id = Column(Integer, default=None)
+    short_name = Column(String(5))
+    status = Column(String, default="Saved")
+    icon = Column(String)
+    py_version = Column(String)
+    r_version = Column(String)
+    py_requirements = Column(Text)
+    r_requirements = Column(Text)
+    py_requirements_compiled = Column(Text)
+    r_requirements_compiled = Column(Text)
+    created_date = Column(DateTime, server_default=func.now())
+    created_by = Column(String)
+
+
+
+class Environment(EnvironmentAttributes):
+    __tablename__ = 'ENVIRONMENT'
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    short_name = Column(String(5), unique=True)
+
+    # Relationship with ArchivedEnvironment
+    archived_versions = relationship("ArchivedEnvironment", back_populates="original_environment")
+
+class ArchivedEnvironment(EnvironmentAttributes):
+    __tablename__ = 'ARCHIVED_ENVIRONMENT'
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    original_env_id = Column(Integer, ForeignKey('ENVIRONMENT.id'))
+    is_latest = Column(Boolean, default=False) 
+
+    # Relationship with Environment
+    original_environment = relationship("Environment", back_populates="archived_versions")
+
+
+
+class JobLogs(Base):
+    __tablename__ = "JOB_LOGS"
+
+    id = Column(Integer, primary_key=True, index=True)
+    created_at = Column(DateTime, default=datetime.now)
+    completed_at = Column(DateTime, nullable=True)
+    log_file_name = Column(String, unique=True, nullable=False)
+    log_file_location = Column(String, nullable=False)
+    status = Column(String)
+    created_by = Column(String)

dataflow/scripts/clone_environment.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+set -e
+
+source_env_name=$1
+target_env_path=$2
+
+# Use an isolated conda package cache to avoid concurrency issues
+export CONDA_PKGS_DIRS=$(mktemp -d)
+# to delete conda package cache after script finishes
+trap 'rm -rf "$CONDA_PKGS_DIRS"' EXIT
+
+# 1. Cloning conda env
+conda create --clone ${source_env_name} --prefix ${target_env_path} --yes
+
+echo "Environment Creation Successful"

dataflow/scripts/create_environment.sh

@@ -11,24 +11,7 @@ export CONDA_PKGS_DIRS=$(mktemp -d)
 trap 'rm -rf "$CONDA_PKGS_DIRS"' EXIT
 
 # 1. Creating conda environment
-conda create --prefix ${conda_env_path} --yes python=${py_version}                         
-${conda_env_path}/bin/pip install --root-user-action ignore ${libraries[@]}      
-
-# 3. Install Dataflow Airflow to a separate path in environment 
-${conda_env_path}/bin/pip install \
-    --force-reinstall --root-user-action ignore \
-    --no-warn-conflicts dataflow-airflow==2.10.5 \
-    --target ${conda_env_path}/bin/airflow-libraries/ \
-    --constraint https://raw.githubusercontent.com//apache/airflow/constraints-2.10.5/constraints-${py_version}.txt || true 
+conda create --prefix ${conda_env_path} --yes python=${py_version} 
 
-files=(
-    ${conda_env_path}/lib/python${py_version}/site-packages/dbt/config/profile.py 
-    ${conda_env_path}/lib/python${py_version}/site-packages/dbt/task/debug.py
-)
-for file in ${files[@]}
-do      
-    awk '{gsub("from dbt.clients.yaml_helper import load_yaml_text", "from dbt.dataflow_config.secrets_manager import load_yaml_text"); print}' $file > temp 
-    mv temp $file
-done
-
-echo "Environment Creation Successful"
+# 2. Install user libraries
+${conda_env_path}/bin/pip install --root-user-action ignore ${libraries[@]}      

dataflow/utils/aws_secrets_manager.py

@@ -6,16 +6,13 @@ class SecretsManagerClient:
     """
     A class to interact with AWS Secrets Manager for managing secrets.
 
-    Args:
-        region_name (str): The AWS region name.
-
     Attributes:
         client: The Boto3 client for Secrets Manager.
         json_handler: An instance of JsonHandler for handling JSON operations.
     """
-    def __init__(self, region_name: str):
+    def __init__(self):
         try:
-            self.client = boto3.client('secretsmanager', region_name=region_name)
+            self.client = boto3.client('secretsmanager')
         except EndpointConnectionError as e:
             self.logger.error(f"Failed to initialize SecretsManagerClient: {e}")
             raise Exception(f"Failed to initialize SecretsManagerClient: Unable to connect to the endpoint. {e}")

{dataflow_core-2.0.7.dist-info → dataflow_core-2.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataflow-core
-Version: 2.0.7
+Version: 2.0.9
 Summary: Dataflow core package
 Author: Dataflow
 Author-email: 

{dataflow_core-2.0.7.dist-info → dataflow_core-2.0.9.dist-info}/RECORD

@@ -10,14 +10,17 @@ authenticator/package/models/session.py,sha256=j6PhbrTMJxEkeDT4Vf5SqGtM_LI_vZy9O
 authenticator/package/models/user.py,sha256=IYogp_vt0yDBG5i936uNPjgTis77VYPzITn9XpQUIyw,788
 dataflow/__init__.py,sha256=WTRg8HMpMWSgxYJ9ZGVldx4k07fAbta3mBmZ1hG9mWE,30
 dataflow/configuration.py,sha256=7To6XwH1eESiYp39eqPcswXWwrdBUdPF6xN6WnazOF0,663
-dataflow/dataflow.py,sha256=viEKxu1bVFtenbPx8etCb7Gf-Hbwv0KvkE7occVbX8I,5136
+dataflow/dataflow.py,sha256=YDARgW2-wdmOQveClU4NhTf2eC15seLWrCQWDQ4gQP8,3488
+dataflow/environment.py,sha256=9_4wgpESP_a3DBT3yaqZHfCOZ4ZBOKCzt9W32gb0biE,19648
 dataflow/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dataflow/models/database.py,sha256=y09pqnglsBBtDZlyhvqDAlpUSFovwAzBAi6jOYl_XNk,896
-dataflow/scripts/create_environment.sh,sha256=nnE2295DCflUGz11RR0k6-TulQlpoXLqEpKZ9QU5t6g,1300
+dataflow/models/environment.py,sha256=kJ4yRAX0ulh7YZsIVMWHkGLrptHbKOMVYtaWtsejVds,2157
+dataflow/scripts/clone_environment.sh,sha256=PJfMWPgiWSkvY-x98WmjeAkRREjC9824JzTazHe2iQQ,390
+dataflow/scripts/create_environment.sh,sha256=ams50MD1r53cHRYDfpAvmEAMsCaCFvlL0cmnRVXhFgY,496
 dataflow/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataflow/utils/aws_secrets_manager.py,sha256=FqHm3YRynv580FpFsS0RfI1MSGY5aq-V7t4blpiYsS4,2588
-dataflow_core-2.0.7.dist-info/METADATA,sha256=em6wCVL-OURnlA9c7tHV_25vCM6fsrEVuRCOuAtIKBo,301
-dataflow_core-2.0.7.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-dataflow_core-2.0.7.dist-info/entry_points.txt,sha256=ppj_EIbYrJJwCPg1kfdsZk5q1N-Ejfis1neYrnjhO8o,117
-dataflow_core-2.0.7.dist-info/top_level.txt,sha256=SZsUOpSCK9ntUy-3Tusxzf5A2e8ebwD8vouPb1dPt_8,23
-dataflow_core-2.0.7.dist-info/RECORD,,
+dataflow/utils/aws_secrets_manager.py,sha256=FddITacFOYnj6bvlU2Y27gOrQdeUJMOKIX1zhsPAhHY,2486
+dataflow_core-2.0.9.dist-info/METADATA,sha256=Pnun0GuJwlKpojnebVwRIwziUWlamY4Pd9rm2_aGLPA,301
+dataflow_core-2.0.9.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+dataflow_core-2.0.9.dist-info/entry_points.txt,sha256=ppj_EIbYrJJwCPg1kfdsZk5q1N-Ejfis1neYrnjhO8o,117
+dataflow_core-2.0.9.dist-info/top_level.txt,sha256=SZsUOpSCK9ntUy-3Tusxzf5A2e8ebwD8vouPb1dPt_8,23
+dataflow_core-2.0.9.dist-info/RECORD,,

{dataflow_core-2.0.7.dist-info → dataflow_core-2.0.9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.1.0)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any