129 lines
3.9 KiB
Python
129 lines
3.9 KiB
Python
"""Pynecone CLI to create, run, and deploy apps."""
|
|
|
|
import os
|
|
|
|
import requests
|
|
import typer
|
|
|
|
from pynecone import constants, utils
|
|
from pynecone.compiler import templates
|
|
|
|
# Create the app.
|
|
cli = typer.Typer()
|
|
|
|
|
|
@cli.command()
|
|
def version():
|
|
"""Get the Pynecone version."""
|
|
utils.console.print(constants.VERSION)
|
|
|
|
|
|
@cli.command()
|
|
def init():
|
|
"""Initialize a new Pynecone app."""
|
|
app_name = utils.get_default_app_name()
|
|
with utils.console.status(f"[bold]Initializing {app_name}") as status:
|
|
# Only create the app directory if it doesn't exist.
|
|
if not os.path.exists(constants.CONFIG_FILE):
|
|
# Create a configuration file.
|
|
with open(constants.CONFIG_FILE, "w") as f:
|
|
f.write(templates.PCCONFIG.format(app_name=app_name))
|
|
utils.console.log(f"Initialize the app directory.")
|
|
|
|
# Initialize the app directory.
|
|
utils.cp(constants.APP_TEMPLATE_DIR, app_name)
|
|
utils.mv(
|
|
os.path.join(app_name, constants.APP_TEMPLATE_FILE),
|
|
os.path.join(app_name, app_name + constants.PY_EXT),
|
|
)
|
|
utils.cp(constants.ASSETS_TEMPLATE_DIR, constants.APP_ASSETS_DIR)
|
|
|
|
# Install bun if it isn't already installed.
|
|
if not os.path.exists(utils.get_bun_path()):
|
|
utils.console.log(f"Installing bun...")
|
|
os.system(constants.INSTALL_BUN)
|
|
|
|
# Initialize the web directory.
|
|
utils.console.log(f"Initializing the web directory.")
|
|
utils.rm(os.path.join(constants.WEB_TEMPLATE_DIR, constants.NODE_MODULES))
|
|
utils.rm(os.path.join(constants.WEB_TEMPLATE_DIR, constants.PACKAGE_LOCK))
|
|
utils.cp(constants.WEB_TEMPLATE_DIR, constants.WEB_DIR)
|
|
utils.console.log(f"[bold green]Finished Initializing: {app_name}")
|
|
|
|
|
|
@cli.command()
|
|
def run(
|
|
env: constants.Env = constants.Env.DEV.value, # type: ignore
|
|
frontend: bool = True,
|
|
backend: bool = True,
|
|
):
|
|
"""Run the app.
|
|
|
|
Args:
|
|
env: The environment to run the app in.
|
|
frontend: Whether to run the frontend.
|
|
backend: Whether to run the backend.
|
|
"""
|
|
utils.console.rule("[bold]Starting Pynecone App")
|
|
app = utils.get_app()
|
|
frontend_cmd = backend_cmd = None
|
|
if env == constants.Env.DEV:
|
|
frontend_cmd, backend_cmd = utils.run_frontend, utils.run_backend
|
|
if env == constants.Env.PROD:
|
|
frontend_cmd, backend_cmd = utils.run_frontend_prod, utils.run_backend_prod
|
|
assert frontend_cmd and backend_cmd, "Invalid env"
|
|
|
|
if frontend:
|
|
frontend_cmd(app)
|
|
if backend:
|
|
backend_cmd(app)
|
|
|
|
|
|
@cli.command()
|
|
def deploy(dry_run: bool = False):
|
|
"""Deploy the app to the hosting service.
|
|
|
|
Args:
|
|
dry_run: Whether to run a dry run.
|
|
"""
|
|
# Get the app config.
|
|
config = utils.get_config()
|
|
config.api_url = utils.get_production_backend_url()
|
|
|
|
# Check if the deploy url is set.
|
|
if config.deploy_url is None:
|
|
typer.echo("This feature is coming soon!")
|
|
typer.echo("Join our waitlist to be notified: https://pynecone.io/waitlist")
|
|
return
|
|
|
|
# Compile the app in production mode.
|
|
typer.echo("Compiling production app")
|
|
app = utils.get_app()
|
|
utils.export_app(app)
|
|
|
|
# Exit early if this is a dry run.
|
|
if dry_run:
|
|
return
|
|
|
|
# Deploy the app.
|
|
data = {"userId": config.username, "projectId": config.app_name}
|
|
original_response = requests.get(config.deploy_url, params=data)
|
|
response = original_response.json()
|
|
print("response", response)
|
|
frontend = response["frontend_resources_url"]
|
|
backend = response["backend_resources_url"]
|
|
|
|
# Upload the frontend and backend.
|
|
with open(constants.FRONTEND_ZIP, "rb") as f:
|
|
response = requests.put(frontend, data=f)
|
|
|
|
with open(constants.BACKEND_ZIP, "rb") as f:
|
|
response = requests.put(backend, data=f)
|
|
|
|
|
|
main = cli
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|