langflow-base 0.0.21__tar.gz

langflow_base-0.0.21/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.1
+Name: langflow-base
+Version: 0.0.21
+Summary: A Python package with a built-in web application
+Home-page: https://github.com/logspace-ai/langflow
+License: MIT
+Keywords: nlp,langchain,openai,gpt,gui
+Author: Logspace
+Author-email: contact@logspace.ai
+Maintainer: Carlos Coelho
+Maintainer-email: carlos@logspace.ai
+Requires-Python: >=3.10,<3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Provides-Extra: all
+Provides-Extra: deploy
+Provides-Extra: local
+Requires-Dist: alembic (>=1.13.0,<2.0.0)
+Requires-Dist: bcrypt (==4.0.1)
+Requires-Dist: cachetools (>=5.3.1,<6.0.0)
+Requires-Dist: chromadb (>=0.4.24,<0.5.0)
+Requires-Dist: cryptography (>=42.0.5,<43.0.0)
+Requires-Dist: docstring-parser (>=0.15,<0.16)
+Requires-Dist: duckdb (>=0.9.2,<0.10.0)
+Requires-Dist: emoji (>=2.11.0,<3.0.0)
+Requires-Dist: fastapi (>=0.110.1,<0.111.0)
+Requires-Dist: gunicorn (>=21.2.0,<22.0.0)
+Requires-Dist: httpx
+Requires-Dist: jq (>=1.7.0,<2.0.0) ; sys_platform != "win32"
+Requires-Dist: langchain (>=0.1.14,<0.2.0)
+Requires-Dist: langchain-anthropic (>=0.1.6,<0.2.0)
+Requires-Dist: langchain-astradb (>=0.1.0,<0.2.0)
+Requires-Dist: langchain-cohere (>=0.1.0,<0.2.0)
+Requires-Dist: langchain-experimental
+Requires-Dist: langchain-openai (>=0.1.1,<0.2.0)
+Requires-Dist: loguru (>=0.7.1,<0.8.0)
+Requires-Dist: multiprocess (>=0.70.14,<0.71.0)
+Requires-Dist: nest-asyncio (>=1.6.0,<2.0.0)
+Requires-Dist: orjson (==3.9.15)
+Requires-Dist: pandas (==2.2.0)
+Requires-Dist: passlib (>=1.7.4,<2.0.0)
+Requires-Dist: pillow (>=10.2.0,<11.0.0)
+Requires-Dist: platformdirs (>=4.2.0,<5.0.0)
+Requires-Dist: pydantic (>=2.5.0,<3.0.0)
+Requires-Dist: pydantic-settings (>=2.1.0,<3.0.0)
+Requires-Dist: pypdf (>=4.1.0,<5.0.0)
+Requires-Dist: python-docx (>=1.1.0,<2.0.0)
+Requires-Dist: python-jose (>=3.3.0,<4.0.0)
+Requires-Dist: python-multipart (>=0.0.7,<0.0.8)
+Requires-Dist: python-socketio (>=5.11.0,<6.0.0)
+Requires-Dist: rich (>=13.7.0,<14.0.0)
+Requires-Dist: sqlmodel (>=0.0.16,<0.0.17)
+Requires-Dist: typer (>=0.12.0,<0.13.0)
+Requires-Dist: uvicorn (>=0.29.0,<0.30.0)
+Requires-Dist: websockets
+Project-URL: Documentation, https://docs.langflow.org
+Project-URL: Repository, https://github.com/logspace-ai/langflow
+Description-Content-Type: text/markdown
+
+

langflow_base-0.0.21/langflow/__main__.py

@@ -0,0 +1,511 @@
+import platform
+import socket
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+import click
+import httpx
+import typer
+from dotenv import load_dotenv
+from langflow.main import setup_app
+from langflow.services.database.utils import session_getter
+from langflow.services.deps import get_db_service, get_settings_service
+from langflow.services.utils import initialize_services, initialize_settings_service
+from langflow.utils.logger import configure, logger
+from multiprocess import Process, cpu_count  # type: ignore
+from packaging import version as pkg_version
+from rich import box
+from rich import print as rprint
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+console = Console()
+
+app = typer.Typer(no_args_is_help=True)
+
+
+def get_number_of_workers(workers=None):
+    if workers == -1 or workers is None:
+        workers = (cpu_count() * 2) + 1
+    logger.debug(f"Number of workers: {workers}")
+    return workers
+
+
+def display_results(results):
+    """
+    Display the results of the migration.
+    """
+    for table_results in results:
+        table = Table(title=f"Migration {table_results.table_name}")
+        table.add_column("Name")
+        table.add_column("Type")
+        table.add_column("Status")
+
+        for result in table_results.results:
+            status = "Success" if result.success else "Failure"
+            color = "green" if result.success else "red"
+            table.add_row(result.name, result.type, f"[{color}]{status}[/{color}]")
+
+        console.print(table)
+        console.print()  # Print a new line
+
+
+def set_var_for_macos_issue():
+    # OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES
+    # we need to set this var is we are running on MacOS
+    # otherwise we get an error when running gunicorn
+
+    if platform.system() in ["Darwin"]:
+        import os
+
+        os.environ["OBJC_DISABLE_INITIALIZE_FORK_SAFETY"] = "YES"
+        # https://stackoverflow.com/questions/75747888/uwsgi-segmentation-fault-with-flask-python-app-behind-nginx-after-running-for-2 # noqa
+        os.environ["no_proxy"] = "*"  # to avoid error with gunicorn
+        logger.debug("Set OBJC_DISABLE_INITIALIZE_FORK_SAFETY to YES to avoid error")
+
+
+def update_settings(
+    config: str,
+    cache: Optional[str] = None,
+    dev: bool = False,
+    remove_api_keys: bool = False,
+    components_path: Optional[Path] = None,
+    store: bool = True,
+):
+    """Update the settings from a config file."""
+
+    # Check for database_url in the environment variables
+    initialize_settings_service()
+    settings_service = get_settings_service()
+    if config:
+        logger.debug(f"Loading settings from {config}")
+        settings_service.settings.update_from_yaml(config, dev=dev)
+    if remove_api_keys:
+        logger.debug(f"Setting remove_api_keys to {remove_api_keys}")
+        settings_service.settings.update_settings(REMOVE_API_KEYS=remove_api_keys)
+    if cache:
+        logger.debug(f"Setting cache to {cache}")
+        settings_service.settings.update_settings(CACHE=cache)
+    if components_path:
+        logger.debug(f"Adding component path {components_path}")
+        settings_service.settings.update_settings(COMPONENTS_PATH=components_path)
+    if not store:
+        logger.debug("Setting store to False")
+        settings_service.settings.update_settings(STORE=False)
+
+
+@app.command()
+def run(
+    host: str = typer.Option(
+        "127.0.0.1", help="Host to bind the server to.", envvar="LANGFLOW_HOST"
+    ),
+    workers: int = typer.Option(
+        1, help="Number of worker processes.", envvar="LANGFLOW_WORKERS"
+    ),
+    timeout: int = typer.Option(300, help="Worker timeout in seconds."),
+    port: int = typer.Option(7860, help="Port to listen on.", envvar="LANGFLOW_PORT"),
+    components_path: Optional[Path] = typer.Option(
+        Path(__file__).parent / "components",
+        help="Path to the directory containing custom components.",
+        envvar="LANGFLOW_COMPONENTS_PATH",
+    ),
+    config: str = typer.Option(
+        Path(__file__).parent / "config.yaml", help="Path to the configuration file."
+    ),
+    # .env file param
+    env_file: Path = typer.Option(
+        None, help="Path to the .env file containing environment variables."
+    ),
+    log_level: str = typer.Option(
+        "critical", help="Logging level.", envvar="LANGFLOW_LOG_LEVEL"
+    ),
+    log_file: Path = typer.Option(
+        "logs/langflow.log", help="Path to the log file.", envvar="LANGFLOW_LOG_FILE"
+    ),
+    cache: Optional[str] = typer.Option(
+        envvar="LANGFLOW_LANGCHAIN_CACHE",
+        help="Type of cache to use. (InMemoryCache, SQLiteCache)",
+        default=None,
+    ),
+    dev: bool = typer.Option(False, help="Run in development mode (may contain bugs)"),
+    path: str = typer.Option(
+        None,
+        help="Path to the frontend directory containing build files. This is for development purposes only.",
+        envvar="LANGFLOW_FRONTEND_PATH",
+    ),
+    open_browser: bool = typer.Option(
+        True,
+        help="Open the browser after starting the server.",
+        envvar="LANGFLOW_OPEN_BROWSER",
+    ),
+    remove_api_keys: bool = typer.Option(
+        False,
+        help="Remove API keys from the projects saved in the database.",
+        envvar="LANGFLOW_REMOVE_API_KEYS",
+    ),
+    backend_only: bool = typer.Option(
+        False,
+        help="Run only the backend server without the frontend.",
+        envvar="LANGFLOW_BACKEND_ONLY",
+    ),
+    store: bool = typer.Option(
+        True,
+        help="Enables the store features.",
+        envvar="LANGFLOW_STORE",
+    ),
+):
+    """
+    Run the Langflow.
+    """
+
+    configure(log_level=log_level, log_file=log_file)
+    set_var_for_macos_issue()
+    # override env variables with .env file
+
+    if env_file:
+        load_dotenv(env_file, override=True)
+
+    update_settings(
+        config,
+        dev=dev,
+        remove_api_keys=remove_api_keys,
+        cache=cache,
+        components_path=components_path,
+        store=store,
+    )
+    # create path object if path is provided
+    static_files_dir: Optional[Path] = Path(path) if path else None
+    app = setup_app(static_files_dir=static_files_dir, backend_only=backend_only)
+    # check if port is being used
+    if is_port_in_use(port, host):
+        port = get_free_port(port)
+
+    options = {
+        "bind": f"{host}:{port}",
+        "workers": get_number_of_workers(workers),
+        "timeout": timeout,
+    }
+
+    # Define an env variable to know if we are just testing the server
+    if "pytest" in sys.modules:
+        return
+
+    if platform.system() in ["Windows"]:
+        # Run using uvicorn on MacOS and Windows
+        # Windows doesn't support gunicorn
+        # MacOS requires an env variable to be set to use gunicorn
+        run_on_windows(host, port, log_level, options, app)
+    else:
+        # Run using gunicorn on Linux
+        run_on_mac_or_linux(host, port, log_level, options, app, open_browser)
+    if open_browser:
+        click.launch(f"http://{host}:{port}")
+
+
+def wait_for_server_ready(host, port):
+    """
+    Wait for the server to become ready by polling the health endpoint.
+    """
+    status_code = 0
+    while status_code != 200:
+        try:
+            status_code = httpx.get(f"http://{host}:{port}/health").status_code
+        except Exception:
+            time.sleep(1)
+
+
+def run_on_mac_or_linux(host, port, log_level, options, app):
+    webapp_process = Process(
+        target=run_langflow, args=(host, port, log_level, options, app)
+    )
+    webapp_process.start()
+    wait_for_server_ready(host, port)
+
+    print_banner(host, port)
+
+
+def run_on_windows(host, port, log_level, options, app):
+    """
+    Run the Langflow server on Windows.
+    """
+    print_banner(host, port)
+    run_langflow(host, port, log_level, options, app)
+
+
+def is_port_in_use(port, host="localhost"):
+    """
+    Check if a port is in use.
+
+    Args:
+        port (int): The port number to check.
+        host (str): The host to check the port on. Defaults to 'localhost'.
+
+    Returns:
+        bool: True if the port is in use, False otherwise.
+    """
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        return s.connect_ex((host, port)) == 0
+
+
+def get_free_port(port):
+    """
+    Given a used port, find a free port.
+
+    Args:
+        port (int): The port number to check.
+
+    Returns:
+        int: A free port number.
+    """
+    while is_port_in_use(port):
+        port += 1
+    return port
+
+
+def version_is_prerelease(version: str):
+    """
+    Check if a version is a pre-release version.
+    """
+    return "a" in version or "b" in version or "rc" in version
+
+
+def get_letter_from_version(version: str):
+    """
+    Get the letter from a pre-release version.
+    """
+    if "a" in version:
+        return "a"
+    if "b" in version:
+        return "b"
+    if "rc" in version:
+        return "rc"
+    return None
+
+
+def build_new_version_notice(current_version: str, package_name: str):
+    """
+    Build a new version notice.
+    """
+    # The idea here is that we want to show a notice to the user
+    # when a new version of Langflow is available.
+    # The key is that if the version the user has is a pre-release
+    # e.g 0.0.0a1, then we find the latest version that is pre-release
+    # otherwise we find the latest stable version.
+    # we will show the notice either way, but only if the version
+    # the user has is not the latest version.
+    if version_is_prerelease(current_version):
+        # curl -s "https://pypi.org/pypi/langflow/json" | jq -r '.releases | keys | .[]' | sort -V | tail -n 1
+        # this command will give us the latest pre-release version
+        package_info = httpx.get(f"https://pypi.org/pypi/{package_name}/json").json()
+        # 4.0.0a1 or 4.0.0b1 or 4.0.0rc1
+        # find which type of pre-release version we have
+        # could be a1, b1, rc1
+        # we want the a, b, or rc and the number
+        suffix_letter = get_letter_from_version(current_version)
+        number_version = current_version.split(suffix_letter)[0]
+        latest_version = sorted(
+            package_info["releases"].keys(),
+            key=lambda x: x.split(suffix_letter)[-1] and number_version in x,
+        )[-1]
+        if version_is_prerelease(latest_version) and latest_version != current_version:
+            return (
+                True,
+                f"A new pre-release version of {package_name} is available: {latest_version}",
+            )
+    else:
+        latest_version = httpx.get(f"https://pypi.org/pypi/{package_name}/json").json()[
+            "info"
+        ]["version"]
+        if not version_is_prerelease(latest_version):
+            return (
+                False,
+                f"A new version of {package_name} is available: {latest_version}",
+            )
+    return False, ""
+
+
+def is_prerelease(version: str) -> bool:
+    return "a" in version or "b" in version or "rc" in version
+
+
+def fetch_latest_version(package_name: str, include_prerelease: bool) -> str:
+    response = httpx.get(f"https://pypi.org/pypi/{package_name}/json")
+    versions = response.json()["releases"].keys()
+    valid_versions = [v for v in versions if include_prerelease or not is_prerelease(v)]
+    if not valid_versions:
+        return None  # Handle case where no valid versions are found
+    return max(valid_versions, key=lambda v: pkg_version.parse(v))
+
+
+def build_version_notice(current_version: str, package_name: str) -> str:
+    latest_version = fetch_latest_version(package_name, is_prerelease(current_version))
+    if latest_version and pkg_version.parse(current_version) < pkg_version.parse(
+        latest_version
+    ):
+        release_type = "pre-release" if is_prerelease(latest_version) else "version"
+        return f"A new {release_type} of {package_name} is available: {latest_version}"
+    return ""
+
+
+def generate_pip_command(package_names, is_pre_release):
+    """
+    Generate the pip install command based on the packages and whether it's a pre-release.
+    """
+    base_command = "pip install"
+    if is_pre_release:
+        return f"{base_command} {' '.join(package_names)} -U --pre"
+    else:
+        return f"{base_command} {' '.join(package_names)} -U"
+
+
+def stylize_text(text: str, to_style: str, is_prerelease: bool) -> str:
+    color = "#42a7f5" if is_prerelease else "#6e42f5"
+    # return "".join(f"[{color}]{char}[/]" for char in text)
+    styled_text = f"[{color}]{to_style}[/]"
+    return text.replace(to_style, styled_text)
+
+
+def print_banner(host: str, port: int):
+    notices = []
+    package_names = []  # Track package names for pip install instructions
+    is_pre_release = False  # Track if any package is a pre-release
+    package_name = ""
+
+    try:
+        from langflow.version import __version__ as langflow_version
+
+        is_pre_release |= is_prerelease(langflow_version)  # Update pre-release status
+        notice = build_version_notice(langflow_version, "langflow")
+        notice = stylize_text(notice, "langflow", is_pre_release)
+        if notice:
+            notices.append(notice)
+        package_names.append("langflow")
+        package_name = "Langflow"
+    except ImportError:
+        langflow_version = None
+
+    # Attempt to handle langflow-base similarly
+    if langflow_version is None:  # This means langflow.version was not imported
+        try:
+            from importlib import metadata
+
+            langflow_base_version = metadata.version("langflow-base")
+            is_pre_release |= is_prerelease(
+                langflow_base_version
+            )  # Update pre-release status
+            notice = build_version_notice(langflow_base_version, "langflow-base")
+            notice = stylize_text(notice, "langflow-base", is_pre_release)
+            if notice:
+                notices.append(notice)
+            package_names.append("langflow-base")
+            package_name = "Langflow Base"
+        except ImportError as e:
+            logger.exception(e)
+            raise e
+
+    # Generate pip command based on the collected data
+    pip_command = generate_pip_command(package_names, is_pre_release)
+
+    # Add pip install command to notices if any package needs an update
+    if notices:
+        notices.append(f"Run '{pip_command}' to update.")
+
+    styled_notices = [f"[bold]{notice}[/bold]" for notice in notices if notice]
+    styled_package_name = stylize_text(
+        package_name, package_name, any("pre-release" in notice for notice in notices)
+    )
+
+    title = f"[bold]Welcome to :chains: {styled_package_name}[/bold]\n"
+    info_text = "Collaborate, and contribute at our [bold][link=https://github.com/logspace-ai/langflow]GitHub Repo[/link][/bold] :rocket:"
+    access_link = f"Access [link=http://{host}:{port}]http://{host}:{port}[/link]"
+
+    panel_content = "\n\n".join([title, *styled_notices, info_text, access_link])
+    panel = Panel(panel_content, box=box.ROUNDED, border_style="blue", expand=False)
+    rprint(panel)
+
+
+def run_langflow(host, port, log_level, options, app):
+    """
+    Run Langflow server on localhost
+    """
+    try:
+        if platform.system() in ["Windows"]:
+            # Run using uvicorn on MacOS and Windows
+            # Windows doesn't support gunicorn
+            # MacOS requires an env variable to be set to use gunicorn
+            import uvicorn
+
+            uvicorn.run(
+                app,
+                host=host,
+                port=port,
+                log_level=log_level.lower(),
+                loop="asyncio",
+            )
+        else:
+            from langflow.server import LangflowApplication
+
+            LangflowApplication(app, options).run()
+    except KeyboardInterrupt:
+        pass
+    except Exception as e:
+        logger.exception(e)
+        sys.exit(1)
+
+
+@app.command()
+def superuser(
+    username: str = typer.Option(..., prompt=True, help="Username for the superuser."),
+    password: str = typer.Option(
+        ..., prompt=True, hide_input=True, help="Password for the superuser."
+    ),
+    log_level: str = typer.Option(
+        "error", help="Logging level.", envvar="LANGFLOW_LOG_LEVEL"
+    ),
+):
+    """
+    Create a superuser.
+    """
+    configure(log_level=log_level)
+    initialize_services()
+    db_service = get_db_service()
+    with session_getter(db_service) as session:
+        from langflow.services.auth.utils import create_super_user
+
+        if create_super_user(db=session, username=username, password=password):
+            # Verify that the superuser was created
+            from langflow.services.database.models.user.model import User
+
+            user: User = session.query(User).filter(User.username == username).first()
+            if user is None or not user.is_superuser:
+                typer.echo("Superuser creation failed.")
+                return
+
+            typer.echo("Superuser created successfully.")
+
+        else:
+            typer.echo("Superuser creation failed.")
+
+
+@app.command()
+def migration(test: bool = typer.Option(True, help="Run migrations in test mode.")):
+    """
+    Run or test migrations.
+    """
+    initialize_services()
+    db_service = get_db_service()
+    if not test:
+        db_service.run_migrations()
+    results = db_service.run_migrations_test()
+    display_results(results)
+
+
+def main():
+    app()
+
+
+if __name__ == "__main__":
+    main()

langflow_base-0.0.21/langflow/alembic/README

@@ -0,0 +1 @@
+Generic single-database configuration.

langflow_base-0.0.21/langflow/alembic/env.py

@@ -0,0 +1,97 @@
+import os
+import warnings
+from logging.config import fileConfig
+
+from alembic import context
+from loguru import logger
+from sqlalchemy import engine_from_config, pool
+
+from langflow.services.database.models import *  # noqa
+from langflow.services.database.service import SQLModel
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = SQLModel.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = os.getenv("LANGFLOW_DATABASE_URL")
+    url = url or config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+        render_as_batch=True,
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+
+    try:
+        from langflow.services.database.factory import DatabaseServiceFactory
+        from langflow.services.deps import get_db_service
+        from langflow.services.manager import initialize_settings_service, service_manager
+
+        initialize_settings_service()
+        service_manager.register_factory(DatabaseServiceFactory())
+        connectable = get_db_service().engine
+    except Exception as e:
+        logger.error(f"Error getting database engine: {e}")
+        url = os.getenv("LANGFLOW_DATABASE_URL")
+        url = url or config.get_main_option("sqlalchemy.url")
+        if url:
+            config.set_main_option("sqlalchemy.url", url)
+        connectable = engine_from_config(
+            config.get_section(config.config_ini_section, {}),
+            prefix="sqlalchemy.",
+            poolclass=pool.NullPool,
+        )
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        with connectable.connect() as connection:
+            context.configure(connection=connection, target_metadata=target_metadata, render_as_batch=True)
+            with context.begin_transaction():
+                context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()