splent-cli 0.0.1__py3-none-any.whl

splent_cli/commands/selenium.py

@@ -0,0 +1,85 @@
+import os
+import subprocess
+import click
+
+from splent_cli.utils.path_utils import PathUtils
+
+
+@click.command(
+    "selenium", help="Executes Selenium tests based on the environment."
+)
+@click.argument("module", required=False)
+def selenium(module):
+    # Absolute paths
+    working_dir = PathUtils.get_working_dir()
+    modules_dir = PathUtils.get_modules_dir()
+
+    def validate_module(module):
+        """Check if the module exists."""
+        if module:
+            module_path = os.path.join(modules_dir, module)
+            if not os.path.exists(module_path):
+                raise click.UsageError(f"Module '{module}' does not exist.")
+            selenium_test_path = os.path.join(
+                module_path, "tests", "test_selenium.py"
+            )
+            if not os.path.exists(selenium_test_path):
+                raise click.UsageError(
+                    f"Selenium test for module '{module}' does not exist at path "
+                    f"'{selenium_test_path}'."
+                )
+
+    def run_selenium_tests_in_local(module):
+        """Run the Selenium tests."""
+        if module:
+            selenium_test_path = os.path.join(
+                modules_dir, module, "tests", "test_selenium.py"
+            )
+            test_command = ["python", selenium_test_path]
+        else:
+            selenium_test_paths = []
+            for module in os.listdir(modules_dir):
+                tests_dir = os.path.join(modules_dir, module, "tests")
+                selenium_test_path = os.path.join(
+                    tests_dir, "test_selenium.py"
+                )
+                if os.path.exists(selenium_test_path):
+                    selenium_test_paths.append(selenium_test_path)
+            test_command = ["python"] + selenium_test_paths
+
+        click.echo(
+            f"Running Selenium tests with command: {' '.join(test_command)}"
+        )
+        subprocess.run(test_command, check=True)
+
+    # Validate module if provided
+    if module:
+        validate_module(module)
+
+    if working_dir == "/app/":
+
+        click.echo(
+            click.style(
+                "Currently it is not possible to run this "
+                "command from a Docker environment, do you want to implement it yourself? ^^",
+                fg="red",
+            )
+        )
+
+    elif working_dir == "":
+        run_selenium_tests_in_local(module)
+
+    elif working_dir == "/vagrant/":
+
+        click.echo(
+            click.style(
+                "Currently it is not possible to run this "
+                "command from a Vagrant environment, do you want to implement it yourself? ^^",
+                fg="red",
+            )
+        )
+
+    else:
+        click.echo(
+            click.style(f"Unrecognized WORKING_DIR: {working_dir}", fg="red")
+        )

splent_cli/commands/test.py

@@ -0,0 +1,45 @@
+import click
+import subprocess
+import os
+
+
+@click.command(
+    "test",
+    help="Runs pytest on the blueprints directory or a specific module.",
+)
+@click.argument("module_name", required=False)
+@click.option(
+    "-k",
+    "keyword",
+    help="Only run tests that match the given substring expression.",
+)
+def test(module_name, keyword):
+    base_path = os.path.join(os.getenv("WORKING_DIR", ""), "app/modules")
+    test_path = base_path
+
+    if module_name:
+        test_path = os.path.join(base_path, module_name)
+        if not os.path.exists(test_path):
+            click.echo(
+                click.style(
+                    f"Module '{module_name}' does not exist.", fg="red"
+                )
+            )
+            return
+        click.echo(f"Running tests for the '{module_name}' module...")
+    else:
+        click.echo("Running tests for all modules...")
+
+    pytest_cmd = ["pytest", "-v", "--ignore-glob=*selenium*", test_path]
+
+    if keyword:
+        pytest_cmd.extend(["-k", keyword])
+
+    try:
+        subprocess.run(pytest_cmd, check=True)
+    except subprocess.CalledProcessError as e:
+        click.echo(click.style(f"Error running tests: {e}", fg="red"))
+
+
+if __name__ == "__main__":
+    test()

splent_cli/commands/update.py

@@ -0,0 +1,159 @@
+import click
+import os
+import subprocess
+
+
+def create_temp_requirements(requirements_path, temp_requirements_path):
+    """Create a temporary requirements file without versions and handle editable sources."""
+    editable_package = None
+    with (
+        open(requirements_path) as f,
+        open(temp_requirements_path, "w") as temp_f,
+    ):
+        for line in f:
+            if line.startswith("-e"):
+                editable_package = line.strip()  # Store the editable package
+            elif line.strip():
+                package = line.split("==")[
+                    0
+                ].strip()  # Remove version information
+                temp_f.write(package + "\n")
+    return editable_package
+
+
+def uninstall_packages():
+    """Uninstall all non-editable packages."""
+    installed_packages = (
+        subprocess.check_output(["pip", "freeze"]).decode("utf-8").splitlines()
+    )
+    non_editable_packages = [
+        pkg for pkg in installed_packages if not pkg.startswith("-e")
+    ]
+    if non_editable_packages:
+        subprocess.run(
+            ["pip", "uninstall", "-y"]
+            + [pkg.split("==")[0] for pkg in non_editable_packages]
+        )
+
+
+def install_packages(requirements_file):
+    """Install packages from a requirements file."""
+    subprocess.run(["pip", "install", "-r", requirements_file])
+
+
+def regenerate_requirements(requirements_path):
+    """Regenerate requirements.txt with resolved versions."""
+    freeze_output = subprocess.check_output(["pip", "freeze"]).decode("utf-8")
+    with open(requirements_path, "w") as f:
+        f.write(freeze_output)
+
+
+def reinstall_editable_package(editable_package):
+    """Reinstall the editable package."""
+    if editable_package:
+        editable_path = editable_package.split()[
+            1
+        ]  # Extract the path from '-e ./app'
+        subprocess.run(
+            ["pip", "install", "-e", editable_path],
+            stdout=subprocess.DEVNULL,  # Suppress output
+            stderr=subprocess.DEVNULL,  # Suppress errors
+        )
+
+
+def clean_up(temp_requirements_path):
+    """Remove the temporary requirements file."""
+    if os.path.exists(temp_requirements_path):
+        os.remove(temp_requirements_path)
+
+
+def update_pip():
+    """Update pip dependencies."""
+    requirements_path = os.path.join(
+        os.getenv("WORKING_DIR", ""), "requirements.txt"
+    )
+    temp_requirements_path = os.path.join(
+        os.getenv("WORKING_DIR", ""), "temp_requirements.txt"
+    )
+
+    editable_package = create_temp_requirements(
+        requirements_path, temp_requirements_path
+    )
+    uninstall_packages()
+    install_packages(temp_requirements_path)
+    regenerate_requirements(requirements_path)
+    reinstall_editable_package(editable_package)
+    clean_up(temp_requirements_path)
+
+
+def update_npm():
+    """Update npm dependencies."""
+    working_dir = os.getenv("WORKING_DIR", "")
+    package_json_path = os.path.join(working_dir, "package.json")
+
+    if not os.path.exists(package_json_path):
+        click.echo(
+            click.style(
+                "No package.json found. Skipping npm update.", fg="yellow"
+            )
+        )
+        return
+
+    try:
+        # Step 1: Update package.json to latest versions
+        subprocess.run(["npx", "npm-check-updates", "-u"], cwd=working_dir)
+
+        # Step 2: Install updated dependencies
+        subprocess.run(["npm", "install"], cwd=working_dir)
+
+        click.echo(
+            click.style("NPM dependencies updated successfully!", fg="green")
+        )
+    except subprocess.CalledProcessError as e:
+        click.echo(click.style(f"Error during npm update: {e}", fg="red"))
+
+
+
+@click.command("update", help="Upload all pip dependencies.")
+def update():
+    """Update both pip and npm dependencies."""
+    try:
+        click.echo("Updating pip dependencies...")
+        update_pip()
+        click.echo("Updating npm dependencies...")
+        update_npm()
+        click.echo(
+            click.style("All dependencies updated successfully!", fg="green")
+        )
+    except Exception as e:
+        click.echo(click.style(f"Error during update: {e}", fg="red"))
+
+
+@click.command("update:pip", help="Upload all pip dependencies.")
+def update_pip_cmd():
+    """Update only pip dependencies."""
+    try:
+        click.echo("Updating pip dependencies...")
+        update_pip()
+        click.echo(
+            click.style("Pip dependencies updated successfully!", fg="green")
+        )
+    except Exception as e:
+        click.echo(click.style(f"Error during pip update: {e}", fg="red"))
+
+
+@click.command("update:npm", help="Upload all npm dependencies.")
+def update_npm_cmd():
+    """Update only npm dependencies."""
+    try:
+        click.echo("Updating npm dependencies...")
+        update_npm()
+        click.echo(
+            click.style("NPM dependencies updated successfully!", fg="green")
+        )
+    except Exception as e:
+        click.echo(click.style(f"Error during npm update: {e}", fg="red"))
+
+
+if __name__ == "__main__":
+    cli()

splent_cli/commands/webpack_compile.py

@@ -0,0 +1,68 @@
+import logging
+import click
+import os
+import subprocess
+
+from splent_cli.utils.path_utils import PathUtils
+
+logger = logging.getLogger(__name__)
+
+MODULES_DIR = PathUtils.get_modules_dir()
+EXCLUDED_MODULES = {".pytest_cache", "__pycache__"}
+
+
+def load_excluded_modules():
+    """Load additional excluded modules from .moduleignore file."""
+    moduleignore_path = os.path.join(os.getenv("WORKING_DIR", ""), ".moduleignore")
+    if os.path.exists(moduleignore_path):
+        with open(moduleignore_path) as f:
+            EXCLUDED_MODULES.update(filter(None, map(str.strip, f)))
+    return EXCLUDED_MODULES
+
+
+EXCLUDED_MODULES = load_excluded_modules()
+
+
+@click.command("webpack:compile", help="Compile webpack for one or all modules.")
+@click.argument("module_name", required=False)
+@click.option("--watch", is_flag=True, help="Enable watch mode for development.")
+def webpack_compile(module_name, watch):
+    """Run webpack for a specific module or all modules."""
+    production = os.getenv("FLASK_ENV", "develop") == "production"
+
+    modules = (
+        [module_name]
+        if module_name
+        else [m for m in os.listdir(MODULES_DIR) if os.path.isdir(os.path.join(MODULES_DIR, m)) and m not in EXCLUDED_MODULES]
+    )
+
+    for module in modules:
+        compile_module(module, watch, production)
+
+
+def compile_module(module, watch, production):
+    """Compile a single module using webpack."""
+    module_path = os.path.join(MODULES_DIR, module)
+    webpack_file = os.path.join(module_path, "assets", "js", "webpack.config.js")
+
+    if not os.path.exists(webpack_file):
+        click.echo(click.style(f"⚠ No webpack.config.js found in {module}, skipping...", fg="yellow"))
+        return
+
+    click.echo(click.style(f"🚀 Compiling {module}...", fg="cyan"))
+
+    mode = "production" if production else "development"
+    extra_flags = "--devtool source-map --no-cache" if not production else ""
+    watch_flag = "--watch" if watch and not production else ""
+
+    webpack_command = f"npx webpack --config {webpack_file} --mode {mode} {watch_flag} {extra_flags} --color"
+
+    try:
+        if watch:
+            subprocess.Popen(webpack_command, shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            click.echo(click.style(f"👀 Watching {module} in {mode} mode...", fg="blue"))
+        else:
+            subprocess.run(webpack_command, shell=True, check=True)
+            click.echo(click.style(f"✅ Successfully compiled {module} in {mode} mode!", fg="green"))
+    except subprocess.CalledProcessError as e:
+        click.echo(click.style(f"❌ Error compiling {module}: {e}", fg="red"))

splent_cli/utils/path_utils.py

@@ -0,0 +1,116 @@
+import os
+import importlib.util
+from dotenv import load_dotenv
+from splent_framework.core.configuration.configuration import uploads_folder_name
+
+load_dotenv()
+
+
+class PathUtils:
+
+    @staticmethod
+    def get_working_dir():
+        return os.getenv("WORKING_DIR", "")
+
+    @staticmethod
+    def get_app_dir():
+        working_dir = PathUtils.get_working_dir()
+        SPLENT = os.getenv("SPLENT", "false").lower() in (
+            "true",
+            "1",
+            "yes",
+        )
+
+        if SPLENT:
+            # Git submodules mode
+            return os.path.join(working_dir, "splent_app", "splent_app")
+
+        # PyPi mode
+        package = importlib.util.find_spec("splent_app")
+        if package and package.origin:
+            return os.path.dirname(package.origin)
+
+        raise FileNotFoundError(
+            "Could not find 'splent_app'. Check the installation."
+        )
+
+    @staticmethod
+    def get_modules_dir():
+        return os.path.join(PathUtils.get_app_dir(), "modules")
+
+    @staticmethod
+    def get_splent_cli_dir():
+        SPLENT = os.getenv("SPLENT", "false").lower() in (
+            "true",
+            "1",
+            "yes",
+        )
+
+        base_dir = os.getcwd()
+        if SPLENT:
+            return os.path.join(base_dir, "splent_cli", "splent_cli")
+
+        return os.path.join(base_dir, "splent_cli")
+
+    @staticmethod
+    def get_splent_cli_templates_dir():
+        return os.path.join(PathUtils.get_splent_cli_dir(), "templates")
+
+    @staticmethod
+    def get_commands_dir():
+        return os.path.join(PathUtils.get_splent_cli_dir(), "commands")
+
+    @staticmethod
+    def get_commands_path():
+        return os.path.abspath(PathUtils.get_commands_dir())
+
+    @staticmethod
+    def get_splent_framework_dir():
+        working_dir = PathUtils.get_working_dir()
+        SPLENT = os.getenv("SPLENT", "false").lower() in (
+            "true",
+            "1",
+            "yes",
+        )
+
+        if SPLENT:
+            # Git submodules mode
+            return os.path.join(working_dir, "splent_framework", "splent_framework")
+
+        # PyPi mode
+        package = importlib.util.find_spec("splent_framework")
+        if package and package.origin:
+            return os.path.dirname(package.origin)
+
+    @staticmethod
+    def get_core_dir():
+        return os.path.join(PathUtils.get_splent_framework_dir(), "core")
+
+    @staticmethod
+    def get_env_dir():
+        return os.path.join(PathUtils.get_working_dir(), ".env")
+
+    @staticmethod
+    def get_app_log_dir():
+        return os.path.join(PathUtils.get_working_dir(), "app.log")
+
+    def get_uploads_dir():
+        working_dir = PathUtils.get_working_dir()
+        SPLENT = os.getenv("SPLENT", "false").lower() in (
+            "true",
+            "1",
+            "yes",
+        )
+
+        if SPLENT:
+            # Git submodules mode
+            return os.path.join(
+                working_dir, "splent_app", uploads_folder_name()
+            )
+
+        # PyPi mode
+        package = importlib.util.find_spec("splent_app")
+        if package and package.origin:
+            return os.path.join(
+                os.path.dirname(package.origin), uploads_folder_name()
+            )

splent_cli-0.0.1.dist-info/LICENSE

@@ -0,0 +1,113 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc.
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users. We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors. You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights. Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received. You must make sure that they, too, receive
+or can get the source code. And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software. For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so. This is fundamentally incompatible with the aim of protecting
+users' freedom to change the software. The systematic pattern of such
+abuse occurs in the area of products for individuals to use, which is
+precisely where it is most unacceptable. Therefore, we have designed
+this version of the GPL to prohibit the practice for those products. If
+such problems arise substantially in other domains, we stand ready to
+extend this provision to those domains in future versions of the GPL, as
+needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary. To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                        TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds
+of works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy. The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+(El texto completo es largo, puedes encontrarlo en https://www.gnu.org/licenses/gpl-3.0.txt)
+