jyapayne/langflow
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

ci: create a nightly build workflow (#3553)

Browse source 
* test poetry install

* Add nightly builds workflow

* remove old comments and fix poetry

* remove old debug statement

* [autofix.ci] apply automated fixes

---------

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
This commit is contained in:
Jordan Frazier 2024-09-05 12:13:04 -07:00 • committed by GitHub
commit 7b3e51f769
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
22 changed files with 1770 additions and 1055 deletions
Download patch file Download diff file Expand all files Collapse all files

80
src/backend/base/langflow/__main__.py
View file

@ -8,6 +8,8 @@ from typing import Optional
import click
import httpx
from langflow.utils.version import get_version_info, fetch_latest_version
from langflow.utils.version import is_pre_release as langflow_is_pre_release
import typer
from dotenv import load_dotenv
from multiprocess import cpu_count # type: ignore
@ -22,7 +24,9 @@ from sqlmodel import select
from langflow.logging.logger import configure, logger
from langflow.main import setup_app
from langflow.services.database.models.folder.utils import create_default_folder_if_it_doesnt_exist
from langflow.services.database.models.folder.utils import (
create_default_folder_if_it_doesnt_exist,
)
from langflow.services.database.utils import session_getter
from langflow.services.deps import get_db_service, get_settings_service, session_scope
from langflow.services.settings.constants import DEFAULT_SUPERUSER
@ -259,13 +263,6 @@ def get_free_port(port):
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.
@ -279,30 +276,10 @@ def get_letter_from_version(version: str):
return None
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) -> Optional[str]:
valid_versions = []
try:
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)]
except Exception as e:
logger.exception(e)
finally:
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))
latest_version = fetch_latest_version(package_name, langflow_is_pre_release(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"
release_type = "pre-release" if langflow_is_pre_release(latest_version) else "version"
return f"A new {release_type} of {package_name} is available: {latest_version}"
return ""
@ -331,35 +308,17 @@ def print_banner(host: str, port: int):
is_pre_release = False # Track if any package is a pre-release
package_name = ""
try:
from langflow.version import __version__ as langflow_version # type: ignore
# Use langflow.utils.version to get the version info
version_info = get_version_info()
langflow_version = version_info["version"]
package_name = version_info["package"]
is_pre_release |= langflow_is_pre_release(langflow_version) # Update pre-release status
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
notice = build_version_notice(langflow_version, package_name)
notice = stylize_text(notice, package_name, is_pre_release)
if notice:
notices.append(notice)
package_names.append(package_name)
# Generate pip command based on the collected data
pip_command = generate_pip_command(package_names, is_pre_release)
@ -528,7 +487,10 @@ def api_key(
typer.echo("Default superuser not found. This command requires a superuser and AUTO_LOGIN to be enabled.")
return
from langflow.services.database.models.api_key import ApiKey, ApiKeyCreate
from langflow.services.database.models.api_key.crud import create_api_key, delete_api_key
from langflow.services.database.models.api_key.crud import (
create_api_key,
delete_api_key,
)
api_key = session.exec(select(ApiKey).where(ApiKey.user_id == superuser.id)).first()
if api_key:

6
src/backend/base/langflow/api/utils.py
View file

@ -85,10 +85,12 @@ def get_is_component_from_data(data: dict):
async def check_langflow_version(component: StoreComponentCreate):
from langflow.version.version import __version__ as current_version # type: ignore
from langflow.version import get_version
__version__ = get_version()
if not component.last_tested_version:
component.last_tested_version = current_version
component.last_tested_version = __version__
langflow_version = get_lf_version_from_pypi()
if langflow_version is None:

7
src/backend/base/langflow/main.py
View file

@ -111,12 +111,9 @@ def get_lifespan(fix_migration=False, socketio_server=None, version=None):
def create_app():
"""Create the FastAPI app and include the router."""
try:
from langflow.version import __version__ # type: ignore
except ImportError:
from importlib.metadata import version
from langflow.utils.version import get_version_info
__version__ = version("langflow-base")
__version__ = get_version_info()["version"]
configure()
lifespan = get_lifespan(version=__version__)

11
src/backend/base/langflow/services/settings/base.py
View file

@ -220,13 +220,12 @@ class Settings(BaseSettings):
# if there is a database in that location
if not info.data["config_dir"]:
raise ValueError("config_dir not set, please set it or provide a database_url")
try:
from langflow.version import is_pre_release # type: ignore
except ImportError:
from importlib import metadata
version = metadata.version("langflow-base")
is_pre_release = "a" in version or "b" in version or "rc" in version
from langflow.utils.version import get_version_info
from langflow.utils.version import is_pre_release as langflow_is_pre_release
version = get_version_info()["version"]
is_pre_release = langflow_is_pre_release(version)
if info.data["save_db_in_config_dir"]:
database_dir = info.data["config_dir"]

85
src/backend/base/langflow/utils/version.py
View file

@ -1,3 +1,9 @@
import httpx
from typing import Optional
from langflow.logging.logger import logger
def _compute_non_prerelease_version(prerelease_version: str) -> str:
prerelease_keywords = ["a", "b", "rc", "dev", "post"]
for keyword in prerelease_keywords:
@ -7,23 +13,80 @@ def _compute_non_prerelease_version(prerelease_version: str) -> str:
def _get_version_info():
try:
from langflow.version import __version__ # type: ignore
"""
Retrieves the version of the package from a possible list of package names.
This accounts for after package names are updated for -nightly builds.
prerelease_version = __version__
version = _compute_non_prerelease_version(prerelease_version)
package = "Langflow"
except ImportError:
from importlib import metadata
Returns:
str: The version of the package
prerelease_version = metadata.version("langflow-base")
version = _compute_non_prerelease_version(prerelease_version)
package = "Langflow Base"
return {"version": prerelease_version, "main_version": version, "package": package}
Raises:
ValueError: If the package is not found from the list of package names.
"""
from importlib import metadata
package_options = [
("langflow", "Langflow"),
("langflow-base", "Langflow Base"),
("langflow-nightly", "Langflow Nightly"),
("langflow-base-nightly", "Langflow Base Nightly"),
]
__version__ = None
for pkg_name, display_name in package_options:
try:
__version__ = metadata.version(pkg_name)
prerelease_version = __version__
version = _compute_non_prerelease_version(prerelease_version)
return {
"version": prerelease_version,
"main_version": version,
"package": display_name,
}
except (ImportError, metadata.PackageNotFoundError):
pass
if __version__ is None:
raise ValueError(f"Package not found from options {package_options}")
VERSION_INFO = _get_version_info()
def is_pre_release(v: str) -> bool:
"""
Returns a boolean indicating whether the version is a pre-release version,
as per the definition of a pre-release segment from PEP 440.
"""
return any(label in v for label in ["a", "b", "rc"])
def is_nightly(v: str) -> bool:
"""
Returns a boolean indicating whether the version is a dev (nightly) version,
as per the definition of a dev segment from PEP 440.
"""
return "dev" in v
def fetch_latest_version(package_name: str, include_prerelease: bool) -> Optional[str]:
from packaging import version as pkg_version
package_name = package_name.replace(" ", "-").lower()
valid_versions = []
try:
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_pre_release(v)]
except Exception as e:
logger.exception(e)
finally:
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 get_version_info():
return VERSION_INFO

1
src/backend/langflow/version/__init__.py
View file

@ -1 +0,0 @@
from .version import __version__, is_pre_release # noqa: F401

46
src/backend/langflow/version/version.py
View file

@ -1,10 +1,38 @@
from importlib import metadata
def get_version() -> str:
"""
Retrieves the version of the package from a possible list of package names.
This accounts for after package names are updated for -nightly builds.
try:
__version__ = metadata.version("langflow")
# Check if the version is a pre-release version
is_pre_release = any(label in __version__ for label in ["a", "b", "rc", "dev", "post"])
except metadata.PackageNotFoundError:
__version__ = ""
is_pre_release = False
del metadata
Returns:
str: The version of the package
Raises:
ValueError: If the package is not found from the list of package names.
"""
from importlib import metadata
pkg_names = [
"langflow",
"langflow-base",
"langflow-nightly",
"langflow-base-nightly",
]
_version = None
for pkg_name in pkg_names:
try:
_version = metadata.version(pkg_name)
except (ImportError, metadata.PackageNotFoundError):
pass
if _version is None:
raise ValueError(f"Package not found from options {pkg_names}")
return _version
def is_pre_release(v: str) -> bool:
"""
Returns a boolean indicating whether the version is a pre-release version,
as per the definition of a pre-release segment from PEP 440.
"""
return any(label in v for label in ["a", "b", "rc"])