kuvy 0.1.0__py3-none-any.whl

kuvy/actions.py

@@ -0,0 +1,176 @@
+from pathlib import Path
+from textwrap import dedent
+import venv
+import tomllib
+import tomli_w
+import subprocess
+
+class ActionsUtils:
+    def __init__(self):
+        current = Path().cwd()
+        
+        venv = None
+        for dir in [current, *current.parents]:
+            dir = dir.joinpath(".venv")
+
+            if dir.exists():
+                venv = dir
+                break
+
+        if not venv:
+            raise FileExistsError("Not in a Python virtual environment!")
+
+        self.venv = venv
+        self.project = self.venv.parent
+        self.project_name = self.project.name
+        self.pyproject = self.project.joinpath("pyproject.toml")
+        self.python = self.venv.joinpath("bin", "python3")
+
+        with open(self.pyproject, "rb") as f:
+            self.pyproject_data = tomllib.load(f)
+
+    def get_kuvy_field(self) -> dict:
+        try:
+            return self.pyproject_data["tool"]["kuvy"]
+        except KeyError:
+            self.generate_kuvy_field()
+            return self.pyproject_data["tool"]["kuvy"]
+
+    def generate_kuvy_field(self):
+        field = {
+            "tool": {
+                "kuvy": {
+                    "run": {
+                        "main": f"src/{self.project_name}/main.py",
+                        "tests": "tests/tests.py"
+                    }
+                }
+            }
+        }
+
+        self.pyproject_data.update(field)
+        with open(self.pyproject, "wb") as f:
+            tomli_w.dump(self.pyproject_data, f)
+
+    def generate_content_kuvy_field(self, content: dict):
+        kuvy = self.pyproject_data
+        kuvy.update(content)
+
+        with open(self.pyproject, "wb") as f:
+            tomli_w.dump(kuvy, f)
+
+class Actions(ActionsUtils):
+    def __init__(self):
+        super().__init__()
+
+    def run(self, file: str, args: list[str] = []):
+        try:
+            run = self.get_kuvy_field()["run"]
+        except KeyError:
+            self.generate_content_kuvy_field({
+                "tool": {
+                    "kuvy": {
+                        "run": {
+                            "main": f"src/{self.project_name}/main.py",
+                            "tests": "tests/tests.py"
+                        }
+                    }
+                }
+            })
+            run = self.get_kuvy_field()["run"]
+
+        try:
+            file = run[file]
+        except KeyError:
+            raise ValueError(f"{file} to execute is not in tool.kuvy.run!")
+
+        subprocess.run([self.python, file, *args])
+
+def new(name: str):
+    MAIN = dedent(
+        f"""\
+        import sys
+
+        def main() -> int:
+            print("hola, mundo.")
+
+            return 0;
+
+        if __name__ == "__main__":
+            sys.exit(main())
+        """
+    )
+
+    PYPROJECT = dedent(
+        f"""\
+        [build-system]
+        requires = ["hatchling"]
+        build-backend = "hatchling.build"
+
+        [project]
+        name = "{name}"
+        version = "0.1.0"
+        description = ""
+        readme = "README.md"
+        requires-python = ""
+        dependencies = [
+
+        ]
+
+        [project.scripts]
+        {name} = "{name}:main.main"
+
+        [tool.kuvy.run]
+        main = "src/{name}/main.py"
+        tests = "tests/tests.py"
+        """
+    )
+
+    README = dedent(
+        f"""\
+        # {name}
+        """
+    )
+
+    project = Path.cwd().joinpath(name)
+    
+    if project.exists():
+        raise FileExistsError(f"Project already exists at: {project}")
+
+    dirs = [
+        project.joinpath("src", name),
+        project.joinpath("tests"),
+    ]
+
+    files = [
+        project.joinpath("src", name, "main.py"),
+        project.joinpath("src", name, "__init__.py"),
+        project.joinpath("pyproject.toml"),
+        project.joinpath("tests", "tests.py"),
+        project.joinpath("README.md"),
+        project.joinpath(".gitignore"),
+    ]
+
+    for dir in dirs:
+        dir.mkdir(parents=True)
+
+    for file in files:
+        file.touch()
+
+        if file.name == "pyproject.toml":
+            with open(file, "w") as f:
+                f.write(PYPROJECT)
+
+        if file.name == "main.py":
+            with open(file, "w") as f:
+                f.write(MAIN)
+
+        if file.name == "README.md":
+            with open(file, "w") as f:
+                f.write(README)
+
+    virtualenv = venv.EnvBuilder()
+    virtualenv.create(project.joinpath(".venv"))
+
+def help():
+    print("Usage: kuvy [action] [args]")

kuvy/args.py

@@ -0,0 +1,51 @@
+from typing import (
+    Iterator,
+)
+import sys
+
+class Args:
+    def __init__(self):
+        self.help:      bool         = False
+        self.new:       str          = ""
+        self.run:       str          = ""
+        self.run_args:  list[str]    = []
+        self.install:   list[str]    = []
+        self.uninstall: list[str]    = []
+        self.update:    list[str]    = []
+        self.build:     bool         = False
+        self.upload:    bool         = False
+
+        self.unknown:   bool         = False
+
+    def read(self):
+        def get_arg(args: Iterator) -> None | str:
+            try:
+                return next(args)
+            except StopIteration:
+                return None
+
+        args = iter(sys.argv[1:])
+
+        while arg := get_arg(args):
+            match arg:
+                case "help":
+                    self.help = True
+
+                case "new":
+                    if arg := get_arg(args):
+                        self.new = arg
+
+                case "run":
+                    self.run = "main"
+
+                    while arg := get_arg(args):
+                        if arg == "--":
+                            while arg := get_arg(args):
+                                self.run_args.append(arg)
+                            return
+
+                        else:
+                            self.run = arg
+
+                case _:
+                    self.unknown = True

kuvy/main.py

@@ -0,0 +1,38 @@
+from kuvy.args import Args
+from kuvy.actions import (
+    Actions,
+    help,
+    new,
+)
+
+import sys
+
+def main() -> int:
+    args = Args()
+    args.read()
+
+    if args.help:
+        print("help")
+        return 0
+
+    elif args.new:
+        try:
+            new(args.new)
+        except FileExistsError as e:
+            print(e)
+            return 1
+
+        print(f"Succesfully created {args.new}!")
+        return 0
+
+    actions = Actions()
+    if args.run:
+        try:
+            actions.run(args.run, args=args.run_args)
+        except ValueError as e:
+            print(e)
+
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main())

kuvy-0.1.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.5
+Name: kuvy
+Version: 0.1.0
+Summary: Lightweight project manager for Python, inspired in Cargo.
+Requires-Python: >=3.11
+Requires-Dist: tomli-w
+Description-Content-Type: text/markdown
+
+# Kuvy

kuvy-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+kuvy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kuvy/actions.py,sha256=nlD2lkfHndpbRa7pChfHFrsG1ClsQ5FSAqKDGXYAhys,4412
+kuvy/args.py,sha256=D671Uf4UduSs9qUzyS4oyaZW17ZJCNdFAakKEXHrQ3Y,1421
+kuvy/main.py,sha256=zuXFvfJoAeZ18ClKIhhpg8tpG9CgyIMxoDIuX7qse4o,643
+kuvy-0.1.0.dist-info/METADATA,sha256=iC-X2u7vu3sppxE-w_HfHuLm1qiD5rlqR3o9EgGZnRY,211
+kuvy-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+kuvy-0.1.0.dist-info/entry_points.txt,sha256=-0WzrAS2ImxAxe0l_Cy2RUOvWRJ7QdSu4Mrb49zQP34,40
+kuvy-0.1.0.dist-info/RECORD,,

kuvy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

kuvy-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kuvy = kuvy:main.main