vellum-ai 0.14.45__tar.gz → 0.14.47__tar.gz

vellum_ai-0.14.47/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.1
+Name: vellum-ai
+Version: 0.14.47
+Summary: 
+License: MIT
+Requires-Python: >=3.9,<4.0
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: Jinja2 (>=3.1.2,<4.0.0)
+Requires-Dist: cdktf (>=0.20.5,<0.21.0)
+Requires-Dist: click (==8.1.7)
+Requires-Dist: docker (==7.1.0)
+Requires-Dist: httpx (>=0.21.2)
+Requires-Dist: openai (>=1.0.0)
+Requires-Dist: orderly-set (>=5.2.2,<6.0.0)
+Requires-Dist: publication (==0.0.3)
+Requires-Dist: pydantic (>=1.9.2)
+Requires-Dist: pydantic-core (>=2.18.2,<3.0.0)
+Requires-Dist: pydash (==7.0.6)
+Requires-Dist: python-dotenv (==1.0.1)
+Requires-Dist: pytz (==2025.1)
+Requires-Dist: pyyaml (==6.0.2)
+Requires-Dist: requests (==2.32.3)
+Requires-Dist: tomli (==2.0.2)
+Requires-Dist: typing_extensions (>=4.0.0)
+Project-URL: Repository, https://github.com/vellum-ai/vellum-python-sdks
+Description-Content-Type: text/markdown
+
+<p align="center">
+   <a href="https://vellum.ai">
+    <picture>
+      <img alt="Vellum README banner" src="https://storage.googleapis.com/vellum-public/assets/github-readme-banner.png" height="128">
+    </picture>
+  </a>
+  <p align="center">
+    <a href="https://vellum.ai">Learn more</a>
+    ·
+    <a href="https://www.vellum.ai/landing-pages/request-demo">Talk to us</a>
+  </p>
+</p>
+
+<p align="center">
+  <a href="https://pepy.tech/project/vellum-ai">
+    <img src="https://img.shields.io/pypi/dm/vellum-ai" alt="Vellum AI PyPI - Downloads" >
+  </a>
+  <a href="https://pypi.org/project/vellum-ai" target="_blank">
+    <img src="https://img.shields.io/pypi/v/vellum-ai?color=%2334D058&label=pypi%20package" alt="Package version">
+  </a>
+  <a href="https://www.ycombinator.com/companies/vellum">
+    <img src="https://img.shields.io/badge/Y%20Combinator-W23-orange?style=flat-square" alt="Y Combinator S24">
+  </a>
+</p>
+
+# Introduction
+
+[Vellum](https://www.vellum.ai/) is the end-to-end development platform for building production-grade AI applications.
+
+### Core Features
+
+- **Orchestration:** A powerful SDK and IDE for defining and debugging the control flow of your AI applications
+- **Prompting:** A best-in-class prompt playground for iterating on and refining prompts between models from any provider
+- **Evaluations**: An evaluations framework that makes it easy to measure the quality of your AI systems at scale
+- **Retrieval:** A ready-to-go service for turning unstructured content into intelligent, context-aware solutions
+  optimized for AI systems
+- **Deployment:** Decouple updates to your AI systems from your application code with an easy integration +
+  one-click deploy
+- **Observability:** Monitor and debug your AI systems in real-time with detailed logs, metrics, and end-user feedback
+
+## Table of Contents
+
+- [Get Started](#get-started)
+- [Client SDK](#client-sdk)
+- [Workflows SDK](#workflows-sdk)
+- [Contributing](#contributing)
+- [Open-source vs paid](#open-source-vs-paid)
+
+## Get Started
+
+Most functionality within the Vellum SDK requires a Vellum account and API key. You can sign up for free [here](https://app.vellum.ai/signup?f=wsdk&utm_source=github&utm_medium=repo_readme&utm_campaign=sdk) or visit our [pricing page](https://www.vellum.ai/pricing) for paid options.
+
+Even without a Vellum account, you can use the Workflows SDK to define the control flow of your AI systems. [Learn
+more below](#workflows-sdk).
+
+## Client SDK
+
+The Vellum Client SDK, found within `src/vellum/client` is a low-level client used to interact directly with the Vellum API.
+Learn more and get started by visiting the [Vellum Client SDK README](/src/vellum/client/README.md).
+
+## Workflows SDK
+
+The Vellum Workflows SDK is a high-level framework for defining and debugging the control flow of AI systems. At
+it's core, it's a powerful workflow engine with syntactic sugar for declaratively defining graphs, the nodes within,
+and the relationships between them.
+
+The Workflows SDK can be used with or without a Vellum account, but a Vellum account is required to use certain
+out-of-box nodes and features, including the ability to push and pull your Workflow definition to Vellum for editing
+and debugging via a UI.
+
+To learn more and get started, visit the [Vellum Workflows SDK README](/src/vellum/workflows/README.md).
+
+## Contributing
+
+See the [CONTRIBUTING.md](/CONTRIBUTING.md) for information on how to contribute to the Vellum SDKs.
+
+## Open-Source vs. Paid
+
+This repo is available under the [MIT expat license](https://github.com/vellum-ai/vellum-python-sdks/blob/main/LICENSE), except
+for the `ee` directory (which has its [license here](https://github.com/vellum-ai/vellum-python-sdks/blob/main/ee/LICENSE)) if applicable.
+
+To learn more, [book a demo](https://www.vellum.ai/landing-pages/request-demo) or see our [pricing page](https://www.vellum.ai/pricing).
+

vellum_ai-0.14.47/ee/vellum_cli/config.py

@@ -0,0 +1,227 @@
+from collections import defaultdict
+from dataclasses import field
+import json
+import os
+from uuid import UUID
+from typing import Dict, List, Literal, Optional, Union
+
+import tomli
+
+from vellum.core.pydantic_utilities import UniversalBaseModel
+from vellum.workflows.state.encoder import DefaultStateEncoder
+
+LOCKFILE_PATH = "vellum.lock.json"
+PYPROJECT_TOML_PATH = "pyproject.toml"
+
+
+class WorkspaceConfig(UniversalBaseModel):
+    name: str
+    api_key: str = "VELLUM_API_KEY"
+    api_url: Optional[str] = None
+
+    def merge(self, other: "WorkspaceConfig") -> "WorkspaceConfig":
+        return WorkspaceConfig(
+            name=self.name or other.name,
+            api_key=self.api_key or other.api_key,
+            api_url=self.api_url or other.api_url,
+        )
+
+
+DEFAULT_WORKSPACE_CONFIG = WorkspaceConfig(name="default", api_key="VELLUM_API_KEY")
+
+
+class WorkflowDeploymentConfig(UniversalBaseModel):
+    id: Optional[UUID] = None
+    label: Optional[str] = None
+    name: Optional[str] = None
+    description: Optional[str] = None
+    release_tags: Optional[List[str]] = None
+
+    def merge(self, other: "WorkflowDeploymentConfig") -> "WorkflowDeploymentConfig":
+        return WorkflowDeploymentConfig(
+            id=self.id or other.id,
+            label=self.label or other.label,
+            name=self.name or other.name,
+            description=self.description or other.description,
+            release_tags=self.release_tags or other.release_tags,
+        )
+
+
+class WorkflowConfig(UniversalBaseModel):
+    module: str
+    workflow_sandbox_id: Optional[str] = None
+    ignore: Optional[Union[str, List[str]]] = None
+    deployments: List[WorkflowDeploymentConfig] = field(default_factory=list)
+    container_image_name: Optional[str] = None
+    container_image_tag: Optional[str] = None
+    workspace: str = DEFAULT_WORKSPACE_CONFIG.name
+    target_directory: Optional[str] = None
+
+    def merge(self, other: "WorkflowConfig") -> "WorkflowConfig":
+        self_deployment_by_id = {
+            deployment.id: deployment for deployment in self.deployments if deployment.id is not None
+        }
+        other_deployment_by_id = {
+            deployment.id: deployment for deployment in other.deployments if deployment.id is not None
+        }
+        all_ids = sorted(set(self_deployment_by_id.keys()).union(set(other_deployment_by_id.keys())))
+        merged_deployments = []
+        for id in all_ids:
+            self_deployment = self_deployment_by_id.get(id)
+            other_deployment = other_deployment_by_id.get(id)
+            if self_deployment and other_deployment:
+                merged_deployments.append(self_deployment.merge(other_deployment))
+            elif self_deployment:
+                merged_deployments.append(self_deployment)
+            elif other_deployment:
+                merged_deployments.append(other_deployment)
+
+        for deployment in self.deployments:
+            if deployment.id is None:
+                merged_deployments.append(deployment)
+
+        for deployment in other.deployments:
+            if deployment.id is None:
+                merged_deployments.append(deployment)
+
+        return WorkflowConfig(
+            module=self.module,
+            workflow_sandbox_id=self.workflow_sandbox_id or other.workflow_sandbox_id,
+            ignore=self.ignore or other.ignore,
+            deployments=merged_deployments,
+            container_image_tag=self.container_image_tag or other.container_image_tag,
+            container_image_name=self.container_image_name or other.container_image_name,
+            workspace=self.workspace or other.workspace,
+        )
+
+
+def merge_workflows_by_sandbox_id(
+    workflows: List[WorkflowConfig], other_workflows: List[WorkflowConfig]
+) -> List[WorkflowConfig]:
+    merged_workflows: List[WorkflowConfig] = []
+    for self_workflow in workflows:
+        if self_workflow.workflow_sandbox_id is None:
+            # If the user defines a workflow in the pyproject.toml without a sandbox_id,
+            # we merge the workflow with one of the ones in the lockfile.
+            other_workflow = next(
+                (
+                    other_workflow
+                    for other_workflow in other_workflows
+                    if self_workflow.workspace == other_workflow.workspace
+                ),
+                None,
+            )
+            if other_workflow is not None:
+                merged_workflows.append(self_workflow.merge(other_workflow))
+            else:
+                merged_workflows.append(self_workflow)
+        else:
+            # If the user defines a workflow in the pyproject.toml with a sandbox_id,
+            # we merge the workflow with one of the ones in the lockfile with the same sandbox_id.
+            other_workflow = next(
+                (
+                    other_workflow
+                    for other_workflow in other_workflows
+                    if self_workflow.workflow_sandbox_id == other_workflow.workflow_sandbox_id
+                ),
+                None,
+            )
+            if other_workflow is not None:
+                merged_workflows.append(self_workflow.merge(other_workflow))
+            else:
+                merged_workflows.append(self_workflow)
+
+    workflow_sandbox_ids_so_far = {workflow.workflow_sandbox_id for workflow in merged_workflows}
+    for other_workflow in other_workflows:
+        if other_workflow.workflow_sandbox_id not in workflow_sandbox_ids_so_far:
+            merged_workflows.append(other_workflow)
+
+    return merged_workflows
+
+
+class VellumCliConfig(UniversalBaseModel):
+    version: Literal["1.0"] = "1.0"
+    workflows: List[WorkflowConfig] = field(default_factory=list)
+    workspaces: List[WorkspaceConfig] = field(default_factory=list)
+
+    def save(self) -> None:
+        lockfile_path = os.path.join(os.getcwd(), LOCKFILE_PATH)
+        with open(lockfile_path, "w") as f:
+            json.dump(self.model_dump(), f, indent=2, cls=DefaultStateEncoder)
+            # Makes sure the file ends with a newline, consistent with most autoformatters
+            f.write("\n")
+
+    def merge(self, other: "VellumCliConfig") -> "VellumCliConfig":
+        if other.version != self.version:
+            raise ValueError("Lockfile version mismatch")
+
+        self_workflows_by_module = self.get_workflows_by_module_mapping()
+        other_workflows_by_module = other.get_workflows_by_module_mapping()
+        all_modules = sorted(set(self_workflows_by_module.keys()).union(set(other_workflows_by_module.keys())))
+        merged_workflows = []
+        for module in all_modules:
+            self_workflows = self_workflows_by_module.get(module)
+            other_workflows = other_workflows_by_module.get(module)
+            if self_workflows and other_workflows:
+                merged_workflows.extend(
+                    merge_workflows_by_sandbox_id(
+                        self_workflows,
+                        other_workflows,
+                    )
+                )
+            elif self_workflows:
+                merged_workflows.extend(self_workflows)
+            elif other_workflows:
+                merged_workflows.extend(other_workflows)
+
+        self_workspace_by_name = {workspace.name: workspace for workspace in self.workspaces}
+        other_workspace_by_name = {workspace.name: workspace for workspace in other.workspaces}
+        all_names = sorted(set(self_workspace_by_name.keys()).union(set(other_workspace_by_name.keys())))
+        merged_workspaces = []
+        for name in all_names:
+            self_workspace = self_workspace_by_name.get(name)
+            other_workspace = other_workspace_by_name.get(name)
+            if self_workspace and other_workspace:
+                merged_workspaces.append(self_workspace.merge(other_workspace))
+            elif self_workspace:
+                merged_workspaces.append(self_workspace)
+            elif other_workspace:
+                merged_workspaces.append(other_workspace)
+
+        return VellumCliConfig(workflows=merged_workflows, workspaces=merged_workspaces, version=self.version)
+
+    def get_workflows_by_module_mapping(self) -> Dict[str, List[WorkflowConfig]]:
+        workflows_by_module = defaultdict(list)
+        for workflow in self.workflows:
+            workflows_by_module[workflow.module].append(workflow)
+        return workflows_by_module
+
+
+def load_vellum_cli_config(root_dir: Optional[str] = None) -> VellumCliConfig:
+    if root_dir is None:
+        root_dir = os.getcwd()
+    lockfile_path = os.path.join(root_dir, LOCKFILE_PATH)
+    if not os.path.exists(lockfile_path):
+        lockfile_data = {}
+    else:
+        with open(lockfile_path, "rb") as f:
+            lockfile_data = json.load(f)
+    lockfile_config = VellumCliConfig.model_validate(lockfile_data)
+
+    pyproject_toml_path = os.path.join(root_dir, PYPROJECT_TOML_PATH)
+    if not os.path.exists(pyproject_toml_path):
+        toml_vellum: Dict = {}
+    else:
+        with open(pyproject_toml_path, "rb") as f:
+            toml_loaded = tomli.load(f)
+        toml_tool = toml_loaded.get("tool", {})
+        if not isinstance(toml_tool, dict):
+            toml_vellum = {}
+
+        toml_vellum = toml_tool.get("vellum")
+        if not isinstance(toml_vellum, dict):
+            # Mypy is wrong. this is totally reachable.
+            toml_vellum = {}  # type: ignore[unreachable]
+    toml_config = VellumCliConfig.model_validate(toml_vellum)
+
+    return toml_config.merge(lockfile_config)

vellum_ai-0.14.47/ee/vellum_cli/push.py

@@ -0,0 +1,258 @@
+from importlib import metadata
+import io
+import json
+import os
+import sys
+import tarfile
+from uuid import UUID
+from typing import List, Optional
+
+from dotenv import load_dotenv
+
+from vellum.client.core.api_error import ApiError
+from vellum.resources.workflows.client import OMIT
+from vellum.types import WorkflowPushDeploymentConfigRequest
+from vellum.workflows.vellum_client import create_vellum_client
+from vellum.workflows.workflows.base import BaseWorkflow
+from vellum_cli.config import DEFAULT_WORKSPACE_CONFIG, WorkflowConfig, WorkflowDeploymentConfig, load_vellum_cli_config
+from vellum_cli.logger import load_cli_logger
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def push_command(
+    module: Optional[str] = None,
+    workflow_sandbox_id: Optional[str] = None,
+    deploy: Optional[bool] = None,
+    deployment_label: Optional[str] = None,
+    deployment_name: Optional[str] = None,
+    deployment_description: Optional[str] = None,
+    release_tags: Optional[List[str]] = None,
+    dry_run: Optional[bool] = None,
+    strict: Optional[bool] = None,
+    workspace: Optional[str] = None,
+) -> None:
+    load_dotenv(dotenv_path=os.path.join(os.getcwd(), ".env"))
+    logger = load_cli_logger()
+    config = load_vellum_cli_config()
+
+    workflow_configs = (
+        [
+            w
+            for w in config.workflows
+            if (module and w.module == module) or (workflow_sandbox_id and w.workflow_sandbox_id == workflow_sandbox_id)
+        ]
+        if module or workflow_sandbox_id
+        else config.workflows
+    )
+
+    if len(workflow_configs) > 1 and workspace:
+        workflow_configs = [w for w in workflow_configs if w.workspace == workspace]
+
+    if len(workflow_configs) == 0:
+        if module and module_exists(module):
+            new_config = WorkflowConfig(
+                module=module,
+                workflow_sandbox_id=workflow_sandbox_id,
+                workspace=workspace or DEFAULT_WORKSPACE_CONFIG.name,
+            )
+            config.workflows.append(new_config)
+            workflow_configs = [new_config]
+        elif not module:
+            raise ValueError("No Workflows found in project to push.")
+        else:
+            raise ValueError(f"No workflow config for '{module}' found in project to push.")
+
+    if len(workflow_configs) > 1:
+        raise ValueError("Multiple workflows found in project to push. Pushing only a single workflow is supported.")
+
+    workflow_config = workflow_configs[0]
+
+    logger.info(f"Loading workflow from {workflow_config.module}")
+    resolved_workspace = workspace or workflow_config.workspace or DEFAULT_WORKSPACE_CONFIG.name
+    workspace_config = (
+        next((w for w in config.workspaces if w.name == resolved_workspace), DEFAULT_WORKSPACE_CONFIG)
+        if workspace
+        else DEFAULT_WORKSPACE_CONFIG
+    )
+    api_key = os.getenv(workspace_config.api_key)
+    if not api_key:
+        raise ValueError(f"No API key value found in environment for workspace '{workspace_config.name}'.")
+
+    if workspace_config.name != workflow_config.workspace:
+        # We are pushing to a new workspace, so we need a new workflow config
+        workflow_config = WorkflowConfig(
+            module=workflow_config.module,
+            workspace=workspace_config.name,
+        )
+        config.workflows.append(workflow_config)
+
+    if (
+        workflow_sandbox_id
+        and workflow_config.workflow_sandbox_id
+        and workflow_config.workflow_sandbox_id != workflow_sandbox_id
+    ):
+        raise ValueError(
+            f"Workflow sandbox id '{workflow_sandbox_id}' is already associated with '{workflow_config.module}'."
+        )
+
+    client = create_vellum_client(
+        api_key=api_key,
+        api_url=workspace_config.api_url,
+    )
+    sys.path.insert(0, os.getcwd())
+
+    # Remove this once we could serialize using the artifact in Vembda
+    # https://app.shortcut.com/vellum/story/5585
+    workflow = BaseWorkflow.load_from_module(workflow_config.module)
+    workflow_display = get_workflow_display(
+        workflow_class=workflow,
+        client=client,
+        dry_run=dry_run or False,
+    )
+    exec_config = workflow_display.serialize()
+
+    container_tag = workflow_config.container_image_tag
+    if workflow_config.container_image_name and not workflow_config.container_image_tag:
+        container_tag = "latest"
+
+    exec_config["runner_config"] = {
+        "sdk_version": metadata.version("vellum-ai"),
+        "container_image_tag": container_tag,
+        "container_image_name": workflow_config.container_image_name,
+    }
+
+    deployment_config: WorkflowPushDeploymentConfigRequest = OMIT
+    deployment_config_serialized: str = OMIT
+    if deploy:
+        cli_deployment_config = (
+            workflow_config.deployments[0] if workflow_config.deployments else WorkflowDeploymentConfig()
+        )
+
+        deployment_config = WorkflowPushDeploymentConfigRequest(
+            label=deployment_label or cli_deployment_config.label,
+            name=deployment_name or cli_deployment_config.name,
+            description=deployment_description or cli_deployment_config.description,
+            release_tags=release_tags or cli_deployment_config.release_tags,
+        )
+
+        # We should check with fern if we could auto-serialize typed fields for us
+        # https://app.shortcut.com/vellum/story/5568
+        deployment_config_serialized = json.dumps({k: v for k, v in deployment_config.dict().items() if v is not None})
+
+    artifact = io.BytesIO()
+    with tarfile.open(fileobj=artifact, mode="w:gz") as tar:
+        module_dir = workflow_config.module.replace(".", os.path.sep)
+        for root, _, files in os.walk(module_dir):
+            for filename in files:
+                if not filename.endswith(".py"):
+                    continue
+
+                file_path = os.path.join(root, filename)
+                # Get path relative to module_dir for tar archive
+                relative_path = os.path.relpath(file_path, module_dir)
+                content_bytes = open(file_path, "rb").read()
+                file_buffer = io.BytesIO(content_bytes)
+
+                tarinfo = tarfile.TarInfo(name=relative_path)
+                tarinfo.size = len(content_bytes)
+
+                tar.addfile(tarinfo, file_buffer)
+
+    artifact.seek(0)
+    artifact.name = f"{workflow_config.module.replace('.', '__')}.tar.gz"
+
+    try:
+        response = client.workflows.push(
+            # Remove this once we could serialize using the artifact in Vembda
+            # https://app.shortcut.com/vellum/story/5585
+            exec_config=json.dumps(exec_config),
+            workflow_sandbox_id=workflow_config.workflow_sandbox_id or workflow_sandbox_id,
+            artifact=artifact,
+            # We should check with fern if we could auto-serialize typed object fields for us
+            # https://app.shortcut.com/vellum/story/5568
+            deployment_config=deployment_config_serialized,  # type: ignore[arg-type]
+            dry_run=dry_run,
+            strict=strict,
+        )
+    except ApiError as e:
+        if e.status_code != 400 or not isinstance(e.body, dict) or "diffs" not in e.body:
+            raise e
+
+        diffs: dict = e.body["diffs"]
+        generated_only = diffs.get("generated_only", [])
+        generated_only_str = (
+            "\n".join(
+                ["Files that were generated but not found in the original project:"]
+                + [f"- {file}" for file in generated_only]
+            )
+            if generated_only
+            else ""
+        )
+
+        original_only = diffs.get("original_only", [])
+        original_only_str = (
+            "\n".join(
+                ["Files that were found in the original project but not generated:"]
+                + [f"- {file}" for file in original_only]
+            )
+            if original_only
+            else ""
+        )
+
+        modified = diffs.get("modified", {})
+        modified_str = (
+            "\n\n".join(
+                ["Files that were different between the original project and the generated artifact:"]
+                + ["\n".join(line.strip() for line in lines) for lines in modified.values()]
+            )
+            if modified
+            else ""
+        )
+
+        reported_diffs = f"""\
+{e.body.get("detail")}
+
+{generated_only_str}
+
+{original_only_str}
+
+{modified_str}
+"""
+        logger.error(reported_diffs)
+        return
+
+    if dry_run:
+        error_messages = [str(e) for e in workflow_display.errors]
+        error_message = "\n".join(error_messages) if error_messages else "No errors found."
+        logger.info(
+            f"""\
+# Workflow Push Report
+
+## Errors
+{error_message}
+
+## Proposed Diffs
+{json.dumps(response.proposed_diffs, indent=2)}
+"""
+        )  # type: ignore[attr-defined]
+    else:
+        default_api_url = client._client_wrapper._environment.default
+        base_url = default_api_url.split("/v1")[0].replace("//api.", "//app.")
+        logger.info(
+            f"""Successfully pushed {workflow_config.module} to Vellum!
+Visit at: {base_url}/workflow-sandboxes/{response.workflow_sandbox_id}"""
+        )
+
+    if not workflow_config.workflow_sandbox_id:
+        workflow_config.workflow_sandbox_id = response.workflow_sandbox_id
+
+    if not workflow_config.deployments and response.workflow_deployment_id:
+        workflow_config.deployments.append(WorkflowDeploymentConfig(id=UUID(response.workflow_deployment_id)))
+
+    config.save()
+    logger.info("Updated vellum.lock.json file.")
+
+
+def module_exists(module_name: str) -> bool:
+    module_path = os.path.join(os.getcwd(), *module_name.split("."))
+    return os.path.exists(module_path) and os.path.isdir(module_path)