subsume wrap under create (#118)

* subsume wrap under create

* typecase Path to str

* improve README

* improvements

* suggested improvements

* fix types

* fix mypy

* fix mypy issues

* more mypy improvements

* suggested changes

Author: madhur-tandon

README.md

@@ -28,44 +28,6 @@ $ pip install pyscript
 
 ## Usage
 
-### wrap
-
-#### Embed a Python script into a PyScript HTML file
-
-```shell
-$ pyscript wrap <filename.py>
-```
-
-This will generate a file called `<filename.html>` by default.
-This can be overwritten with the `-o` or `--output` option:
-
-```shell
-$ pyscript wrap <filename.py> -o <another_filename.html>
-```
-
-#### Open the script inside the browser using the `--show` option
-
-```shell
-$ pyscript wrap <filename.py> --show
-```
-
-#### Set a title for the browser tab
-
-You can set the title of the browser tab with the `--title` option:
-
-```shell
-$ pyscript wrap <filename.py> --title "My cool app!"
-```
-
-#### Very simple command examples with `--command` option
-
-The `-c` or `--command` option can be used to demo very simple cases.
-In this case, if the `--show` option is used and no `--output` file is used, a temporary file will be generated.
-
-```shell
-$ pyscript wrap -c 'print("Hello World!")' --show
-```
-
 ### run
 
 #### Spin up a local server to run on the path and specified port
@@ -109,3 +71,52 @@ The following files will be created:
 - `index.html`: start page for the project
 - `pyscript.toml`: project metadata and config file
 - `main.py`: a "Hello world" python starter module
+
+#### Use --wrap to embed a python file OR a command string
+
+- ##### Embed a Python script into a PyScript HTML file
+
+```shell
+$ pyscript create --wrap <filename.py>
+```
+
+This will generate a project i.e. a new directory named `filename` under the current directory.
+
+Similar to the above, interactive prompts will further ask for metadata information.
+
+The following files will be created:
+
+- `index.html`: start page for the project
+- `pyscript.toml`: project metadata and config file
+- `main.py`: contains code of `filename.py`
+
+This can be overridden with the `-o` or `--output` option:
+
+```shell
+$ pyscript create --wrap <filename.py> -o <another_filename.html>
+```
+
+i.e. the HTML file created in the above directory will now be named `another_filename.html`
+
+- ##### Very simple command examples with `--command` option
+
+The `-c` or `--command` option can be used to demo very simple cases.
+
+By default, the name of the project folder created will be `pyscript-command-app` with the HTML file named `index.html`.
+
+`-o/--output` option can be used with the `-c/--command` option to configure name of the project folder as well
+as the name of the resulting HTML file.
+
+```shell
+$ pyscript create --wrap -c 'print("Hello World!")' -o <output_filename.html>
+```
+
+This will generate a project i.e. a new directory named `output_filename` under the current directory.
+
+Similar to the above, interactive prompts will further ask for metadata information.
+
+The following files will be created:
+
+- `output_filename.html`: start page for the project
+- `pyscript.toml`: project metadata and config file
+- `main.py`: contains code of the command string passed via `-c/--command`

src/pyscript/_generator.py

@@ -68,55 +68,16 @@ def save_config_file(config_file: Path, configuration: dict):
             toml.dump(configuration, fp)
 
 
-def string_to_html(
-    code: str,
-    title: str,
-    output_path: Path,
-    template_name: str = "wrap.html",
-    pyscript_version: str = LATEST_PYSCRIPT_VERSION,
-) -> None:
-    """Write a Python script string to an HTML file template.
-
-    Params:
-
-        - code(str): string containing the application code to be written to the
-                     PyScript app template
-        - title(str): application title, that will be placed as title of the html
-                      app template
-        - output_path(Path): path where to write the new html file
-        - template_name(str): name of the template to be used
-        - pyscript_version(str): version of pyscript to be used
-
-    Output:
-        (None)
-    """
-    template = _env.get_template(template_name)
-    with output_path.open("w") as fp:
-        fp.write(
-            template.render(code=code, title=title, pyscript_version=pyscript_version)
-        )
-
-
-def file_to_html(
-    input_path: Path,
-    title: str,
-    output_path: Optional[Path],
-    template_name: str = "wrap.html",
-    pyscript_version: str = LATEST_PYSCRIPT_VERSION,
-) -> None:
-    """Write a Python script string to an HTML file template."""
-    output_path = output_path or input_path.with_suffix(".html")
-    with input_path.open("r") as fp:
-        string_to_html(fp.read(), title, output_path, template_name, pyscript_version)
-
-
 def create_project(
-    app_name: str,
+    app_or_file_name: Optional[str],
     app_description: str,
     author_name: str,
     author_email: str,
     pyscript_version: str = LATEST_PYSCRIPT_VERSION,
     project_type: str = "app",
+    wrap: bool = False,
+    command: Optional[str] = None,
+    output: Optional[str] = None,
 ) -> None:
     """
     New files created:
@@ -126,40 +87,63 @@ def create_project(
     index.html - start page for the project
     """
     date_stamp = datetime.date.today()
+
+    if wrap:
+        if command:
+            # app_or_file_name is None in this case
+            assert app_or_file_name is None
+            if output:
+                app_name = output.removesuffix(".html")
+            else:
+                app_name = "pyscript-command-app"
+        else:
+            assert app_or_file_name is not None
+            app_name = app_or_file_name.removesuffix(".py")
+    else:
+        assert app_or_file_name is not None
+        app_name = app_or_file_name
+
     context = {
         "name": app_name,
         "description": app_description,
         "type": "app",
         "author_name": author_name,
         "author_email": author_email,
-        "version": f"{date_stamp.year}.{date_stamp.month}.1",
+        "version": f"{date_stamp.year}.{'{:02d}'.format(date_stamp.month)}.1",
     }
     app_dir = Path(".") / app_name
     app_dir.mkdir()
     manifest_file = app_dir / config["project_config_filename"]
 
     save_config_file(manifest_file, context)
+    output_path = app_dir / "index.html" if output is None else app_dir / output
 
-    index_file = app_dir / "index.html"
     if project_type == "app":
         template = "basic.html"
-    elif project_type == "plugin":
-        template = "plugin.html"
     else:
         raise ValueError(
-            f"Unknown project type: {project_type}. Valid values are: 'app' and 'plugin'"
+            f"Unknown project type: {project_type}. Valid values are: 'app'"
         )
 
-    # Save the new python file
     python_filepath = app_dir / "main.py"
-    with python_filepath.open("w", encoding="utf-8") as fp:
-        fp.write(TEMPLATE_PYTHON_CODE)
+
+    if not wrap:
+        # Save the new python file
+        with python_filepath.open("w", encoding="utf-8") as fp:
+            fp.write(TEMPLATE_PYTHON_CODE)
+    else:
+        if command:
+            with python_filepath.open("w", encoding="utf-8") as fp:
+                fp.write(command)
+        else:
+            assert app_or_file_name is not None
+            python_filepath.write_bytes(Path(app_or_file_name).read_bytes())
 
     create_project_html(
         app_name,
         config["project_main_filename"],
         config["project_config_filename"],
-        index_file,
+        output_path,
         pyscript_version=pyscript_version,
         template=template,
     )

src/pyscript/cli.py

@@ -7,7 +7,7 @@
 from pyscript import __version__, app, console, plugins, typer
 from pyscript.plugins import hookspecs
 
-DEFAULT_PLUGINS = ["create", "wrap", "run"]
+DEFAULT_PLUGINS = ["create", "run"]
 
 
 def ok(msg: str = ""):

src/pyscript/plugins/create.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 import typer
 
 from pyscript import LATEST_PYSCRIPT_VERSION, app, cli, plugins
@@ -6,10 +8,12 @@
 
 @app.command()
 def create(
-    app_name: str = typer.Argument(..., help="The name of your new app."),
-    app_description: str = typer.Option(..., prompt=True),
-    author_name: str = typer.Option(..., prompt=True),
-    author_email: str = typer.Option(..., prompt=True),
+    app_or_file_name: Optional[str] = typer.Argument(
+        None, help="The name of your new app or path to an input .py script"
+    ),
+    app_description: str = typer.Option(None, help="App description"),
+    author_name: str = typer.Option(None, help="Name of the author"),
+    author_email: str = typer.Option(None, help="Email of the author"),
     pyscript_version: str = typer.Option(
         LATEST_PYSCRIPT_VERSION,
         "--pyscript-version",
@@ -18,25 +22,68 @@ def create(
     project_type: str = typer.Option(
         "app",
         "--project-type",
-        help="Type of project that is being created. Supported types are: 'app' or 'plugin'",
+        help="Type of project that is being created. Supported types are: 'app'",
+    ),
+    wrap: bool = typer.Option(
+        False,
+        "-w",
+        "--wrap",
+        help="Use wrap mode i.e. embed a python script into an HTML file",
+    ),
+    command: Optional[str] = typer.Option(
+        None,
+        "-c",
+        "--command",
+        help="If provided, embed a single command string. Meant to be used with `--wrap`",
+    ),
+    output: Optional[str] = typer.Option(
+        None,
+        "-o",
+        "--output",
+        help="""Name of the resulting HTML output file. Meant to be used with `-w/--wrap`""",
     ),
 ):
     """
     Create a new pyscript project with the passed in name, creating a new
-    directory in the current directory.
+    directory in the current directory. Alternatively, use `--wrap` so as to embed
+    a python file instead.
     """
+    if not app_or_file_name and not command:
+        raise cli.Abort(
+            "Must provide either an input '.py' file or a command with the '-c' option."
+        )
+
+    if app_or_file_name and command:
+        raise cli.Abort("Cannot provide both an input '.py' file and '-c' option.")
+
+    if (output or command) and (not wrap):
+        raise cli.Abort(
+            """`--output/-o`, and `--command/-c`
+            are meant to be used with `--wrap/-w`"""
+        )
+
+    if not app_description:
+        app_description = typer.prompt("App description")
+    if not author_name:
+        author_name = typer.prompt("Author name")
+    if not author_email:
+        author_email = typer.prompt("Author email")
+
     try:
         create_project(
-            app_name,
+            app_or_file_name,
             app_description,
             author_name,
             author_email,
             pyscript_version,
             project_type,
+            wrap,
+            command,
+            output,
         )
     except FileExistsError:
         raise cli.Abort(
-            f"A directory called {app_name} already exists in this location."
+            f"A directory called {app_or_file_name} already exists in this location."
         )