@motiadev/core 0.1.0-beta.28 → 0.1.0-beta.29

package/dist/src/python/context.py

@@ -0,0 +1,21 @@
+from typing import Any, List, Optional
+from type_definitions import HandlerResult
+from rpc import RpcSender
+from rpc_state_manager import RpcStateManager
+from logger import Logger
+
+class Context:
+    def __init__(
+        self,
+        trace_id: str,
+        flows: List[str],
+        rpc: RpcSender,
+    ):
+        self.trace_id = trace_id
+        self.flows = flows
+        self.rpc = rpc
+        self.state = RpcStateManager(rpc)
+        self.logger = Logger(self.trace_id, self.flows, rpc)
+
+    async def emit(self, event: Any) -> Optional[HandlerResult]:
+        return await self.rpc.send('emit', event)

package/dist/src/python/get-config.py

@@ -2,7 +2,6 @@ import sys
 import json
 import importlib.util
 import os
-from typing import Any, Callable
 
 # get the FD from ENV
 NODEIPCFD = int(os.environ["NODE_CHANNEL_FD"])
@@ -39,11 +38,14 @@ async def run_python_module(file_path: str) -> None:
         spec.loader.exec_module(module)
 
         # Print the config if it exists
-        if hasattr(module, 'config'):
-            sendMessage(module.config)
-        else:
+        if not hasattr(module, 'config'):
             raise AttributeError(f"No 'config' found in module {file_path}")
 
+        if 'middleware' in module.config:
+            del module.config['middleware']
+
+        sendMessage(module.config)
+
     except Exception as error:
         print('Error running Python module:', str(error), file=sys.stderr)
         sys.exit(1)

package/dist/src/python/logger.py

@@ -1,6 +1,6 @@
 import time
 from typing import Any, Dict, Optional
-from rpc import RpcSender, serialize_for_json
+from rpc import RpcSender
 
 class Logger:
     def __init__(self, trace_id: str, flows: list[str], rpc: RpcSender):

package/dist/src/python/middleware.py

@@ -0,0 +1,17 @@
+from typing import Any, Callable
+from functools import reduce
+from context import Context
+
+def compose_middleware(*middlewares):
+    """Compose multiple middleware functions into a single middleware"""
+    def compose_two(f: Callable, g: Callable) -> Callable:
+        async def composed(data: Any, context: Context, next_fn: Callable):
+            async def wrapped_next(d=data):
+                return await g(d, context, next_fn)
+            return await f(data, context, wrapped_next)
+        return composed
+
+    if not middlewares:
+        return lambda data, context, next_fn: next_fn()
+    
+    return reduce(compose_two, middlewares)

package/dist/src/python/python-runner.py

@@ -4,116 +4,105 @@ import importlib.util
 import os
 import asyncio
 import traceback
-from logger import Logger
-from rpc import RpcSender, serialize_for_json
-from rpc_state_manager import RpcStateManager
-from typing import Any, Optional
-import functools
-
-def parse_args(arg: str) -> Any:
-    from types import SimpleNamespace
-    
+from typing import Optional, Any, Callable, List, Dict
+
+from rpc import RpcSender
+from type_definitions import FlowConfig, ApiResponse
+from context import Context
+from validation import validate_with_jsonschema
+from middleware import compose_middleware
+
+def parse_args(arg: str) -> Dict:
+    """Parse command line arguments into HandlerArgs"""
     try:
-        return json.loads(arg, object_hook=lambda d: SimpleNamespace(**d))
+        return json.loads(arg)
     except json.JSONDecodeError:
         print('Error parsing args:', arg)
         return arg
 
-class Context:
-    def __init__(self, args: Any, rpc: RpcSender, is_api_handler: bool = False):
-        self.trace_id = args.traceId
-        self.traceId = args.traceId
-        self.flows = args.flows
-        self.rpc = rpc
-        self.state = RpcStateManager(rpc)
-        self.logger = Logger(self.trace_id, self.flows, rpc)
-        try:
-            self._loop = asyncio.get_running_loop()
-        except RuntimeError:
-            self._loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(self._loop)
-        self.is_api_handler = is_api_handler
-        self._pending_tasks = []
-
-    async def emit(self, event: Any):
-        if self.is_api_handler:
-            self.rpc.send_no_wait('emit', event)
+async def validate_handler_input(
+    module: Any,
+    args: Dict,
+    context: Context,
+    is_api_handler: bool
+) -> Optional[ApiResponse]:
+    """Validate handler input based on module configuration"""
+    if not hasattr(args, "contextInFirstArg") or hasattr(module, "config"):
+        return None
+
+    config: FlowConfig = module.config
+    input_data = args.get("data")
+
+    if is_api_handler and hasattr(input_data, "body") and hasattr(config, "bodySchema"):
+        body = input_data.get("body", {})
+        body_schema = config.get("bodySchema", {})
+        validation_result = validate_with_jsonschema(body, body_schema)
+
+        if not validation_result["success"]:
+            return ApiResponse(
+                status=400,
+                body={"message": f'Input validation error: {validation_result["error"]}'}
+            )
+        input_data.body = validation_result['data']
+    
+    elif not is_api_handler and config.input is not None:
+        validation_result = validate_with_jsonschema(input_data, config.get("input", {}))
+
+        if not validation_result["success"]:
+            context.logger.info(f'Input Validation Error: {validation_result["error"]}', validation_result['details'])
             return None
-        else:
-            return await self.rpc.send('emit', event)
         
-    # Add wrapper to handle non-awaited emit coroutine
-    def __getattribute__(self, name):
-        attr = super().__getattribute__(name)
-        if name == 'emit' and asyncio.iscoroutinefunction(attr):
-            @functools.wraps(attr)
-            def wrapper(*args, **kwargs):
-                coro = attr(*args, **kwargs)
-                # Check if this is being awaited
-                frame = sys._getframe(1)
-                if frame.f_code.co_name != '__await__':
-                    task = asyncio.create_task(coro)
-                    def handle_exception(t):
-                        if t.done() and not t.cancelled() and t.exception():
-                            print(f"Unhandled exception in background task: {t.exception()}", file=sys.stderr)
-                    task.add_done_callback(handle_exception)
-                    return task
-                return coro
-            return wrapper
-        return attr
-
-async def run_python_module(file_path: str, rpc: RpcSender, args: Any) -> None:
+        input_data = validation_result["data"]
+
+    return None
+
+async def run_python_module(file_path: str, rpc: RpcSender, args: Dict) -> None:
+    """Execute a Python module with the given arguments"""
     try:
-        # Get the directory containing the module file
         module_dir = os.path.dirname(os.path.abspath(file_path))
-        
-        # Add module directory to Python path
-        if module_dir not in sys.path:
-            sys.path.insert(0, module_dir)
-            
-        # Get the flows directory (parent of steps)
         flows_dir = os.path.dirname(module_dir)
-        if flows_dir not in sys.path:
-            sys.path.insert(0, flows_dir)
-
-        contextInFirstArg = args.contextInFirstArg
+        
+        for path in [module_dir, flows_dir]:
+            if path not in sys.path:
+                sys.path.insert(0, path)
 
-        # Load the module dynamically
         spec = importlib.util.spec_from_file_location("dynamic_module", file_path)
         if spec is None or spec.loader is None:
             raise ImportError(f"Could not load module from {file_path}")
             
         module = importlib.util.module_from_spec(spec)
-        # Add module's directory as its __package__
         module.__package__ = os.path.basename(module_dir)
         spec.loader.exec_module(module)
 
-        # Check if the handler function exists
-        if not hasattr(module, 'handler'):
+        if not hasattr(module, "handler"):
             raise AttributeError(f"Function 'handler' not found in module {file_path}")
 
-        context = Context(args, rpc)
+        config = module.config
+        is_api_handler = (config and config.get("type") == "api")
 
-        # Check if this is an API handler
-        is_api_handler = False
-        if hasattr(module, 'config'):
-            if isinstance(module.config, dict) and module.config.get('type') == 'api':
-                is_api_handler = True
-            elif hasattr(module.config, 'type') and module.config.type == 'api':
-                is_api_handler = True
+        trace_id = args.get("traceId")
+        flows = args.get("flows") or []
+        data = args.get("data")
+        context_in_first_arg = args.get("contextInFirstArg")
+        context = Context(trace_id, flows, rpc)
 
-        # Create context with is_api_handler flag
-        context = Context(args, rpc, is_api_handler)
+        validation_result = await validate_handler_input(module, args, context, is_api_handler)
+        if validation_result:
+            await rpc.send('result', validation_result)
+            return
 
-        if contextInFirstArg:
-            result = await module.handler(context)
-        else:
-            if hasattr(args.data, 'body'):
-                args.data.body = serialize_for_json(args.data.body)
-            result = await module.handler(args.data, context)
+    
+        middlewares: List[Callable] = config.get("middleware", [])
+        composed_middleware = compose_middleware(*middlewares)
+        
+        async def handler_fn():
+            if context_in_first_arg:
+                return await module.handler(context)
+            else:
+                return await module.handler(data, context)
+
+        result = await composed_middleware(data, context, handler_fn)
 
-        # For API handlers, we want to return immediately without waiting for background tasks
-        # This prevents the API from getting stuck
         if not is_api_handler:
             pending = asyncio.all_tasks() - {asyncio.current_task()}
             if pending:
@@ -122,14 +111,8 @@ async def run_python_module(file_path: str, rpc: RpcSender, args: Any) -> None:
         if result:
             await rpc.send('result', result)
 
-        # For non-API handlers, ensure all pending tasks are completed before closing
-        if not is_api_handler:
-            pending = asyncio.all_tasks() - {asyncio.current_task()}
-            if pending:
-                await asyncio.gather(*pending)
-
         rpc.close()
-        rpc.send_no_wait('close', None)
+        rpc.send_no_wait("close", None)
         
     except Exception as error:
         print(f'Error running Python module: {error}', file=sys.stderr)
@@ -138,7 +121,7 @@ async def run_python_module(file_path: str, rpc: RpcSender, args: Any) -> None:
 
 if __name__ == "__main__":
     if len(sys.argv) < 2:
-        print('Usage: python pythonRunner.py <file-path> <arg>', file=sys.stderr)
+        print("Usage: python pythonRunner.py <file-path> <arg>", file=sys.stderr)
         sys.exit(1)
 
     file_path = sys.argv[1]
@@ -150,5 +133,7 @@ if __name__ == "__main__":
     except RuntimeError:
         loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
-    tasks = asyncio.gather(rpc.init(), run_python_module(file_path, rpc, parse_args(arg)))
+
+    args = parse_args(arg) if arg else None
+    tasks = asyncio.gather(rpc.init(), run_python_module(file_path, rpc, args))
     loop.run_until_complete(tasks)

package/dist/src/python/type_definitions.py

@@ -0,0 +1,34 @@
+from typing import TypeVar, Callable, Coroutine, Union, Dict, List, Optional
+from types import SimpleNamespace
+from rpc import RpcSender
+
+# Generic type for JSON schema validation
+T = TypeVar('T')
+
+# Custom types
+JsonSchema = Dict[str, any]
+ValidationResult = Dict[str, Union[bool, Dict, str]]
+HandlerResult = Optional[Dict[str, any]]
+HandlerFunction = Callable[..., Coroutine[any, any, HandlerResult]]
+
+class FlowConfig(SimpleNamespace):
+    type: str
+    input: Optional[JsonSchema]
+    bodySchema: Optional[JsonSchema]
+
+class HandlerArgs(SimpleNamespace):
+    traceId: str
+    flows: List[str]
+    data: Union[Dict, SimpleNamespace]
+    contextInFirstArg: bool
+
+class ApiResponse:
+    def __init__(
+        self,
+        status: int,
+        body: Dict[str, any],
+        headers: Optional[Dict[str, str]] = None
+    ):
+        self.status = status
+        self.body = body
+        self.headers = headers or {'Content-Type': 'application/json'} 

package/dist/src/python/validation.py

@@ -0,0 +1,56 @@
+from typing import TypeVar, Dict, Any
+from jsonschema import validate as json_validate
+from jsonschema.exceptions import ValidationError
+from type_definitions import ValidationResult, JsonSchema
+
+T = TypeVar('T')
+
+def namespace_to_dict(obj: Any) -> Dict:
+    """Convert SimpleNamespace to dict recursively"""
+    if isinstance(obj, list):
+        return [namespace_to_dict(item) for item in obj]
+    elif hasattr(obj, '__dict__'):
+        return {k: namespace_to_dict(v) for k, v in obj.__dict__.items()}
+    return obj
+
+def create_validation_error(error: ValidationError) -> ValidationResult:
+    """Create a user-friendly validation error message"""
+    property_name = error.path[-1] if error.path else error.schema_path[-1]
+    
+    if error.validator == 'required':
+        missing_field = error.schema['required'][0]
+        error_msg = f"Missing required field: '{missing_field}'"
+    elif error.validator == 'type':
+        expected_type = error.validator_value
+        error_msg = f"Invalid type for '{property_name}'. Expected {expected_type}"
+    elif error.validator == 'properties':
+        error_msg = f"Invalid property: '{property_name}'"
+    elif error.validator == 'items':
+        error_msg = f"Invalid item in array: '{property_name}'"
+    else:
+        error_msg = f"Validation error for '{property_name}': {error.message}"
+
+    details = f"\nReceived: {str(error.instance)}" if hasattr(error, 'instance') else ""
+    
+    return {
+        'success': False,
+        'error': error_msg,
+        'details': details,
+    }
+
+def validate_with_jsonschema(data: T, schema: JsonSchema) -> ValidationResult:
+    """Validate data against a JSON schema"""
+    try:
+        dict_data = namespace_to_dict(data)
+        json_validate(instance=dict_data, schema=schema)
+        return {
+            'success': True,
+            'data': dict_data
+        }
+    except ValidationError as e:
+        return create_validation_error(e)
+    except Exception as e:
+        return {
+            'success': False,
+            'error': f"Validation Error: {str(e)}"
+        }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@motiadev/core",
   "description": "Core functionality for the Motia framework, providing the foundation for building event-driven workflows.",
   "main": "dist/index.js",
-  "version": "0.1.0-beta.28",
+  "version": "0.1.0-beta.29",
   "dependencies": {
     "body-parser": "^1.20.3",
     "colors": "^1.4.0",
@@ -32,12 +32,14 @@
     "typescript": "^5.7.2"
   },
   "scripts": {
+    "postinstall": "python3 -m venv python_modules && python_modules/bin/pip install -r requirements.txt",
     "move:python": "mkdir -p dist/src/python && cp src/python/*.py dist/src/python",
     "move:rb": "mkdir -p dist/src/ruby && cp src/ruby/*.rb dist/src/ruby",
     "move:steps": "cp src/steps/*.ts dist/src/steps",
     "build": "rm -rf dist && tsc && npm run move:python && npm run move:rb && npm run move:steps",
     "lint": "eslint --config ../../eslint.config.js",
     "watch": "tsc --watch",
-    "test": "jest"
+    "test": "PATH=python_modules/bin:$PATH jest",
+    "clean": "rm -rf python_modules dist"
   }
 }

package/python_modules/bin/Activate.ps1

@@ -0,0 +1,247 @@
+<#
+.Synopsis
+Activate a Python virtual environment for the current PowerShell session.
+
+.Description
+Pushes the python executable for a virtual environment to the front of the
+$Env:PATH environment variable and sets the prompt to signify that you are
+in a Python virtual environment. Makes use of the command line switches as
+well as the `pyvenv.cfg` file values present in the virtual environment.
+
+.Parameter VenvDir
+Path to the directory that contains the virtual environment to activate. The
+default value for this is the parent of the directory that the Activate.ps1
+script is located within.
+
+.Parameter Prompt
+The prompt prefix to display when this virtual environment is activated. By
+default, this prompt is the name of the virtual environment folder (VenvDir)
+surrounded by parentheses and followed by a single space (ie. '(.venv) ').
+
+.Example
+Activate.ps1
+Activates the Python virtual environment that contains the Activate.ps1 script.
+
+.Example
+Activate.ps1 -Verbose
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and shows extra information about the activation as it executes.
+
+.Example
+Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
+Activates the Python virtual environment located in the specified location.
+
+.Example
+Activate.ps1 -Prompt "MyPython"
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and prefixes the current prompt with the specified string (surrounded in
+parentheses) while the virtual environment is active.
+
+.Notes
+On Windows, it may be required to enable this Activate.ps1 script by setting the
+execution policy for the user. You can do this by issuing the following PowerShell
+command:
+
+PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+For more information on Execution Policies: 
+https://go.microsoft.com/fwlink/?LinkID=135170
+
+#>
+Param(
+    [Parameter(Mandatory = $false)]
+    [String]
+    $VenvDir,
+    [Parameter(Mandatory = $false)]
+    [String]
+    $Prompt
+)
+
+<# Function declarations --------------------------------------------------- #>
+
+<#
+.Synopsis
+Remove all shell session elements added by the Activate script, including the
+addition of the virtual environment's Python executable from the beginning of
+the PATH variable.
+
+.Parameter NonDestructive
+If present, do not remove this function from the global namespace for the
+session.
+
+#>
+function global:deactivate ([switch]$NonDestructive) {
+    # Revert to original values
+
+    # The prior prompt:
+    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
+        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
+        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
+    }
+
+    # The prior PYTHONHOME:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
+        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
+    }
+
+    # The prior PATH:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
+        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
+    }
+
+    # Just remove the VIRTUAL_ENV altogether:
+    if (Test-Path -Path Env:VIRTUAL_ENV) {
+        Remove-Item -Path env:VIRTUAL_ENV
+    }
+
+    # Just remove VIRTUAL_ENV_PROMPT altogether.
+    if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) {
+        Remove-Item -Path env:VIRTUAL_ENV_PROMPT
+    }
+
+    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
+    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
+        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
+    }
+
+    # Leave deactivate function in the global namespace if requested:
+    if (-not $NonDestructive) {
+        Remove-Item -Path function:deactivate
+    }
+}
+
+<#
+.Description
+Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
+given folder, and returns them in a map.
+
+For each line in the pyvenv.cfg file, if that line can be parsed into exactly
+two strings separated by `=` (with any amount of whitespace surrounding the =)
+then it is considered a `key = value` line. The left hand string is the key,
+the right hand is the value.
+
+If the value starts with a `'` or a `"` then the first and last character is
+stripped from the value before being captured.
+
+.Parameter ConfigDir
+Path to the directory that contains the `pyvenv.cfg` file.
+#>
+function Get-PyVenvConfig(
+    [String]
+    $ConfigDir
+) {
+    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
+
+    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
+    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
+
+    # An empty map will be returned if no config file is found.
+    $pyvenvConfig = @{ }
+
+    if ($pyvenvConfigPath) {
+
+        Write-Verbose "File exists, parse `key = value` lines"
+        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
+
+        $pyvenvConfigContent | ForEach-Object {
+            $keyval = $PSItem -split "\s*=\s*", 2
+            if ($keyval[0] -and $keyval[1]) {
+                $val = $keyval[1]
+
+                # Remove extraneous quotations around a string value.
+                if ("'""".Contains($val.Substring(0, 1))) {
+                    $val = $val.Substring(1, $val.Length - 2)
+                }
+
+                $pyvenvConfig[$keyval[0]] = $val
+                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
+            }
+        }
+    }
+    return $pyvenvConfig
+}
+
+
+<# Begin Activate script --------------------------------------------------- #>
+
+# Determine the containing directory of this script
+$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$VenvExecDir = Get-Item -Path $VenvExecPath
+
+Write-Verbose "Activation script is located in path: '$VenvExecPath'"
+Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
+Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
+
+# Set values required in priority: CmdLine, ConfigFile, Default
+# First, get the location of the virtual environment, it might not be
+# VenvExecDir if specified on the command line.
+if ($VenvDir) {
+    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
+}
+else {
+    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
+    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
+    Write-Verbose "VenvDir=$VenvDir"
+}
+
+# Next, read the `pyvenv.cfg` file to determine any required value such
+# as `prompt`.
+$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
+
+# Next, set the prompt from the command line, or the config file, or
+# just use the name of the virtual environment folder.
+if ($Prompt) {
+    Write-Verbose "Prompt specified as argument, using '$Prompt'"
+}
+else {
+    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
+    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
+        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
+        $Prompt = $pyvenvCfg['prompt'];
+    }
+    else {
+        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)"
+        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
+        $Prompt = Split-Path -Path $venvDir -Leaf
+    }
+}
+
+Write-Verbose "Prompt = '$Prompt'"
+Write-Verbose "VenvDir='$VenvDir'"
+
+# Deactivate any currently active virtual environment, but leave the
+# deactivate function in place.
+deactivate -nondestructive
+
+# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
+# that there is an activated venv.
+$env:VIRTUAL_ENV = $VenvDir
+
+if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
+
+    Write-Verbose "Setting prompt to '$Prompt'"
+
+    # Set the prompt to include the env name
+    # Make sure _OLD_VIRTUAL_PROMPT is global
+    function global:_OLD_VIRTUAL_PROMPT { "" }
+    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
+    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
+
+    function global:prompt {
+        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
+        _OLD_VIRTUAL_PROMPT
+    }
+    $env:VIRTUAL_ENV_PROMPT = $Prompt
+}
+
+# Clear PYTHONHOME
+if (Test-Path -Path Env:PYTHONHOME) {
+    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
+    Remove-Item -Path Env:PYTHONHOME
+}
+
+# Add the venv to the PATH
+Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
+$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"