simple-oop 2026.2.1__tar.gz

simple_oop-2026.2.1/.gitignore

@@ -0,0 +1,6 @@
+.git
+.idea
+.venv
+dist
+test
+__pycache__/

simple_oop-2026.2.1/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 J. Günthner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

simple_oop-2026.2.1/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: simple-oop
+Version: 2026.2.1
+Summary: Placeholder description
+Author-email: Guenthner <guenthner.jonathan@gmail.com>
+License-File: LICENSE.txt
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: colorama
+Requires-Dist: jinja2
+Requires-Dist: pydantic
+Description-Content-Type: text/markdown
+
+# Placeholder
+
+Placeholder description

simple_oop-2026.2.1/README.md

@@ -0,0 +1,3 @@
+# Placeholder
+
+Placeholder description

simple_oop-2026.2.1/makefile

@@ -0,0 +1,29 @@
+py=.venv/bin/python
+pip=.venv/bin/pip
+user=guenthner
+program-name=simple-oop
+
+install_dependencies:
+	$(pip) install build hatchling twine
+
+set_user:
+	cp ~/.pypirc_$(user) ~/.pypirc
+
+build: clean version
+	$(py) -m build
+
+version:
+	vinc
+
+clean:
+	mkdir dist -p
+	touch dist/fuck
+	rm dist/*
+
+upload: set_user build
+	$(py) -m twine upload --repository pypi dist/* $(flags)
+
+reload: upload
+	pipx upgrade $(program-name)
+	pipx upgrade $(program-name)
+	$(program-name) --version . .

simple_oop-2026.2.1/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "simple-oop"
+version = "2026.2.1" # version
+authors = [
+    { name = "Guenthner", email = "guenthner.jonathan@gmail.com" },
+]
+description = "Placeholder description"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent"
+]
+dependencies = ["pydantic", "jinja2", "colorama"]
+keywords = []
+
+[project.scripts]
+simple-oop = "simple_oop:command_entry_point"

simple_oop-2026.2.1/simple_oop/__init__.py

@@ -0,0 +1,132 @@
+import argparse
+import logging
+import os
+from abc import ABC, abstractmethod
+from argparse import ArgumentParser
+from pathlib import Path
+from typing import Union
+
+import colorama
+from colorama import Fore
+from pydantic import ValidationError
+
+from .config import Config, VariableType
+from .discovery import discover
+from .node import NodeContext
+from .version import program_version
+
+colorama.init(autoreset=True)
+
+from .code_gen import TemplateEnvironment  # I put this here to stop it from being moved (professional, I know)
+
+PROGRAM_NAME = "simple-oop"
+
+log = logging.getLogger(PROGRAM_NAME)
+console = logging.StreamHandler()
+log.addHandler(console)
+log.setLevel(logging.DEBUG)
+console.setFormatter(
+    logging.Formatter(
+        f"{{asctime}} [{Fore.YELLOW}{{levelname:>5}}{Fore.RESET}] {Fore.BLUE}{{name}}{Fore.RESET}: {{message}}",
+        style="{", datefmt="W%W %a %I:%M"))
+
+colorama.init(autoreset=True)
+
+
+def command_entry_point():
+    try:
+        main()
+    except KeyboardInterrupt:
+        log.warning("Program was interrupted by user")
+
+
+class Mode(ABC):
+    modes: list[type['Mode']] = []
+    name: Union[None, str] = None
+    description: Union[None, str] = None
+
+    @classmethod
+    @abstractmethod
+    def create_parser(cls, obj) -> ArgumentParser:
+        parser = obj.add_parser(cls.name, description=cls.description, help=cls.description)
+        parser.set_defaults(mode=cls)
+        return parser
+
+    @classmethod
+    @abstractmethod
+    def call(cls, args):
+        pass
+
+
+@Mode.modes.append
+class Generate(Mode):
+    name = "generate"
+    description = "TODO"  # TODO
+
+    @classmethod
+    def create_parser(cls, obj) -> ArgumentParser:
+        parser = super().create_parser(obj)
+        parser.add_argument("-w", "--working-directory", type=Path, default=Path(os.getcwd()))
+        parser.add_argument("--dump-tree", type=str, default=None)
+        return parser
+
+    @classmethod
+    def call(cls, args: argparse.Namespace) -> None:
+        os.chdir(args.working_directory.resolve())
+
+        config_file = Path("simple-oop/config.json")
+        assert config_file.exists(), f"File {config_file} does not exist at {os.getcwd()}"
+        try:
+            c = Config.model_validate_json(config_file.read_text())
+        except ValidationError as e:
+            print(e)
+            return
+
+        if args.verbose:
+            log.debug("Using following config:")
+            print(c.model_dump_json(indent=4))
+
+        ctx = NodeContext(c)
+
+        discover(ctx, c.input_directories[0])
+
+        if ctx.errors > 0:
+            log.error(f"Discovery failed with {ctx.errors} error(s)")
+            return
+
+        if args.verbose:
+            log.debug("Found the following type structure:")
+            ctx.print_types()
+
+        if args.dump_tree is not None:
+            assert args.dump_tree in c.variables
+            assert c.variables[args.dump_tree] == VariableType.NODE
+
+            roots = [n for n in ctx.nodes.values() if n.variables[args.dump_tree] is None]
+            for r in roots:
+                r.print_tree(args.dump_tree)
+
+        gen = TemplateEnvironment(ctx)
+
+        for template in c.templates:
+            gen.generate(template)
+
+
+def main():
+    parser = ArgumentParser(prog=PROGRAM_NAME,
+                            description="Placeholder description",
+                            allow_abbrev=True, add_help=True, exit_on_error=True)
+
+    parser.add_argument('-v', '--verbose', action='store_true', help="Show more output")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {program_version}")
+
+    subparsers = parser.add_subparsers(title="Modes", description="Possible modes of operation", required=True)
+    for mode in Mode.modes:
+        mode.create_parser(subparsers)
+
+    args = parser.parse_args()
+
+    log.setLevel(logging.DEBUG if args.verbose else logging.INFO)
+    log.debug("Starting program...")
+
+    args.mode.call(args)

simple_oop-2026.2.1/simple_oop/__main__.py

@@ -0,0 +1,3 @@
+from . import command_entry_point
+
+command_entry_point()

simple_oop-2026.2.1/simple_oop/code_gen.py

@@ -0,0 +1,81 @@
+import logging
+from pathlib import Path
+from typing import Any
+
+from jinja2 import FileSystemLoader, Environment, TemplateNotFound
+
+from simple_oop import NodeContext
+from simple_oop.config import TemplateConfig
+from simple_oop.node import Node
+
+log = logging.getLogger("simple-oop")
+
+
+class TemplateEnvironment:
+    generated_file_marker = "// autogenerated by simple-oop\n"
+
+    def __init__(self, ctx: NodeContext):
+        self.ctx = ctx
+        self.env = Environment(loader=FileSystemLoader(ctx.config.template_directory), autoescape=False)
+
+    def check_file(self, file: Path) -> bool:
+        file.parent.mkdir(parents=True, exist_ok=True)
+        if file.exists() and not file.read_text().startswith(self.generated_file_marker):
+            log.error(f"Any files generated by simple-oop must start with "
+                      f"\"{self.generated_file_marker}\" otherwise they will "
+                      f"not be overwritten, you probably deleted that line. It is "
+                      f"normally automatically prepended")
+            return False
+
+        return True
+
+    def render_filename(self, filename: str, node: Node) -> str:
+        return self.env.from_string(filename).render(node=node)
+
+    def generate(self, template_config: TemplateConfig):
+        try:
+            template = Template(self, template_config)
+        except TemplateNotFound as e:
+            print(e)
+            return
+        out = self.ctx.config.output_directory
+
+        if template.config.foreach is None:
+            template.render(out / template_config.name, {
+                "nodes": self.ctx.nodes.values()
+            })
+        else:
+            for node in self.ctx.nodes.values():
+                if template.node_matches(node):
+                    filename = self.render_filename(template_config.name, node)
+                    template.render(out / filename, {
+                        "nodes": self.ctx.nodes.values(),
+                        "node": node
+                    })
+
+
+class Template:
+    def __init__(self, env: TemplateEnvironment, config: TemplateConfig):
+        self.env: TemplateEnvironment = env
+        self.config: TemplateConfig = config
+        self.jinja_template: Any
+
+        try:
+            self.jinja_template = self.env.env.get_template(config.name)
+        except TemplateNotFound as e:
+            self.jinja_template = None
+            raise e
+
+    def render(self, file: Path, variables: dict[str, Any]):
+        if not self.env.check_file(file):
+            return
+
+        file.write_text(self.env.generated_file_marker + self.jinja_template.render(**variables))
+        log.info(f"Generated {file.name}")
+
+    def node_matches(self, node: Node):
+        assert self.config.foreach is not None
+        for r in self.config.foreach:
+            if not node[r]:
+                return False
+        return True

simple_oop-2026.2.1/simple_oop/config.py

@@ -0,0 +1,89 @@
+import logging
+import os
+import re
+from enum import Enum
+from pathlib import Path
+from typing import Annotated, Any, Optional
+
+from colorama import Fore
+from pydantic import BaseModel, ConfigDict, BeforeValidator, AfterValidator
+
+log = logging.getLogger("simple-oop")
+
+
+def coerce_list_to_str(value) -> str:
+    if isinstance(value, str):
+        return value
+    if isinstance(value, list):
+        value = "".join(value)
+        log.debug(f"Joining regex to {value}")
+        return value
+    raise ValueError(f"Value {value} is not a string or a list of strings")
+
+
+def require_exists(path: Path) -> Path:
+    path = Path(os.curdir) / path
+    assert path.exists(), f"Path {path} does not exist"
+    return path
+
+
+def require_is_dir(path: Path) -> Path:
+    assert path.is_dir(), f"Path {path} is not a directory"
+    return path
+
+
+EXTENDED_REGEX = Annotated[re.Pattern, BeforeValidator(coerce_list_to_str)]
+PATH_EXISTS = Annotated[Path, AfterValidator(require_exists)]
+DIRECTORY_EXISTS = Annotated[PATH_EXISTS, AfterValidator(require_is_dir)]
+
+
+class VariableType(Enum):
+    STRING = "string"
+    BOOL = "bool"
+    NODE = "node"
+
+    def default(self) -> Any:
+        match self:
+            case self.BOOL:
+                return False
+            case _:
+                return None
+
+    def color(self) -> str:
+        match self:
+            case self.STRING:
+                return Fore.YELLOW
+            case self.BOOL:
+                return Fore.BLUE
+            case self.NODE:
+                return Fore.GREEN
+
+    def format(self, name: str, value: Any) -> str:
+        match self:
+            case self.STRING:
+                return f"{self.color()}{value}{Fore.RESET} ({name}) "
+            case self.BOOL:
+                assert isinstance(value, bool), f"Value {value} is not a bool for field {name}"
+                if value:
+                    return f"{self.color()}{name}{Fore.RESET} "
+                else:
+                    return ""
+            case self.NODE:
+                return f"{self.color()}{name}->{str(value)}{Fore.RESET}"
+
+
+class TemplateConfig(BaseModel):
+    model_config = ConfigDict(frozen=True)
+    name: str
+    foreach: Optional[list[str]] = None
+
+
+class Config(BaseModel):
+    model_config = ConfigDict(frozen=True)
+    regex: EXTENDED_REGEX
+    file_regex: EXTENDED_REGEX
+    variables: dict[str, VariableType]
+    input_directories: list[DIRECTORY_EXISTS]
+    output_directory: DIRECTORY_EXISTS
+    template_directory: DIRECTORY_EXISTS
+    templates: list[TemplateConfig]

simple_oop-2026.2.1/simple_oop/discovery.py

@@ -0,0 +1,63 @@
+import logging
+import sys
+from pathlib import Path
+
+from colorama import Fore
+
+from .config import Config
+from .node import NodeContext
+
+log = logging.getLogger("simple-oop")
+
+
+def check_match_variables(config: Config, g: dict[str, str], file: Path, match_string: str) -> None:
+    if "name" not in g:
+        print(f"The regex must always fill the \"name\" field, "
+              f"this did not happen in {file} for:\n"
+              f"{match_string}")
+        raise ValueError()
+
+    for name, value in g.items():
+        if name not in config.variables:
+            print(f"Any variable used in the regex must be declared in the variables list.\n"
+                  f"The variable {Fore.RED}{name}{Fore.RESET} was not declared.")
+            raise ValueError()
+
+
+def parse_match(ctx: NodeContext, file: Path, m) -> None:
+    g = m.groupdict()
+    match_string = m.string[m.start(0):m.end(0)]
+
+    check_match_variables(ctx.config, g, file, match_string)
+    node = ctx.node(g["name"])
+
+    node.declare(file, match_string)
+
+    for name, _type in ctx.config.variables.items():
+        node.set_variable(name, g.get(name, None), _type)
+
+
+def discover_file(ctx: NodeContext, path: Path):
+    if not ctx.config.file_regex.fullmatch(path.name):
+        return
+    try:
+        string = path.read_text("utf-8")
+    except UnicodeDecodeError:
+        log.error(f"Failed to decode file \"{path}\" using utf-8")
+        sys.exit(1)
+
+    for m in ctx.config.regex.finditer(string):
+        try:
+            parse_match(ctx, path, m)
+        except ValueError as e:
+            if str(e) != "":
+                raise e
+            ctx.errors += 1
+
+
+def discover(ctx: NodeContext, path: Path):
+    if path.is_file():
+        discover_file(ctx, path)
+    else:
+        for file in path.iterdir():
+            discover(ctx, file)

simple_oop-2026.2.1/simple_oop/node.py

@@ -0,0 +1,107 @@
+import logging
+import sys
+from collections import defaultdict
+from pathlib import Path
+from typing import Optional, Any
+
+from colorama import Fore
+
+from simple_oop import Config
+from simple_oop.config import VariableType
+
+log = logging.getLogger("simple-oop")
+
+
+class Node:
+    def __init__(self, ctx: 'NodeContext', name: str) -> None:
+        self.ctx: 'NodeContext' = ctx
+
+        self.file: Optional[Path] = None
+        self.declaration: Optional[str] = None
+
+        self.variables: dict[str, Any] = {name: _type.default() for name, _type in ctx.config.variables.items()}
+        self.variables["name"] = name
+
+        self.references: dict[str, list['Node']] = defaultdict(list)
+
+    def declare(self, file: Path, declaration: str) -> None:
+        assert (self.declaration is None) == (self.file is None)
+
+        if self.declaration is not None:
+            print(f"{Fore.YELLOW}Node {Fore.RED}{self.variables["name"]}{Fore.YELLOW} was declared twice.{Fore.RESET}\n"
+                  f"Once in {self.file}:\n"
+                  f"{self.declaration}\n"
+                  f"Then in {file}:\n"
+                  f"{declaration}")
+            raise ValueError
+
+        self.file = file
+        self.declaration = declaration
+
+    def set_variable(self, name: str, value: Optional[str], _type: VariableType) -> None:
+        actual_value: Any
+        match _type:
+            case VariableType.BOOL:
+                actual_value = value is not None
+            case VariableType.NODE if value is not None:
+                actual_value = self.ctx.node(value)
+                actual_value.references[name].append(self)
+            case _:
+                actual_value = value
+
+        self.variables[name] = actual_value
+
+    def print(self, skip_types=frozenset()):
+        for name, _type in self.ctx.config.variables.items():
+            if _type in skip_types: continue
+            value = self.variables[name]
+            print(_type.format(name, value), end="")
+
+        print()
+
+    def print_tree(self, tree_field, indent=0) -> None:
+        print(end=" " * 4 * indent)
+        self.print(frozenset([VariableType.NODE]))
+        for child in self.references[tree_field]:
+            child.print_tree(tree_field, indent + 1)
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __str__(self) -> str:
+        return self.variables["name"]
+
+    def __getitem__(self, item: str):
+        invert: bool = False
+
+        if item.startswith("not"):
+            invert = True
+            item = item.removeprefix("not").lstrip()
+
+        if item not in self.ctx.config.variables:
+            log.error(
+                f"Variable {item} used in a template declaration or "
+                f"template and was not declared in \"variables\"")
+            sys.exit(1)
+
+        value = self.variables[item]
+        if invert:
+            return not value
+        else:
+            return value
+
+
+class NodeContext:
+    def __init__(self, config: Config):
+        self.config: Config = config
+        self.nodes: dict[str, Node] = {}
+        self.errors: int = 0
+
+    def node(self, name: str) -> Node:
+        if name not in self.nodes:
+            self.nodes[name] = Node(self, name)
+        return self.nodes[name]
+
+    def print_types(self):
+        for node in self.nodes.values():
+            node.print()

simple_oop-2026.2.1/simple_oop/version.py

@@ -0,0 +1 @@
+program_version = "2026.2.1"

simple_oop-2026.2.1/vinc.json

@@ -0,0 +1,17 @@
+{
+	"template": "<YEAR>.<MONTH>.<COUNTER>",
+	"version": "2026.2.1",
+	"YEAR": 2026,
+	"MONTH": 2,
+	"COUNTER": 1,
+	"targets": {
+		"pyproject.toml": {
+			"find": "\"<VERSION>\"\\s*#\\s*version",
+			"replace": "\"<VERSION>\" # version"
+		},
+		"simple_oop/version.py": {
+			"find": ".+",
+			"replace": "program_version = \"<VERSION>\""
+		}
+	}
+}