pyexcel2mustache 0.1.1__tar.gz

pyexcel2mustache-0.1.1/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: pyexcel2mustache
+Version: 0.1.1
+Summary: Convert Excel files to Mustache templates based on a defined schema.
+Author-email: oNsemy <onsemy@gmail.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: openpyxl>=3.1.0
+Requires-Dist: pystache>=0.6.0
+
+# pyexcel2mustache
+
+Convert Excel (`xlsx`) sheets into Mustache templates based on a defined schema. This is now a distributable Python package.
+
+## Features
+
+- Convert multiple sheets at once using customizable schemas.
+- Skip sheets starting with an underscore (`_`).
+- Robust and modular architecture following SOLID principles.
+- Easy installation via `pip`.
+
+## Installation
+
+Install the package from the local directory:
+
+```bash
+pip install .
+```
+
+Once published to PyPI, you can install it using:
+
+```bash
+pip install pyexcel2mustache
+```
+
+## Requirements
+
+- Python 3.8+
+- Dependencies (automatically installed): `openpyxl`, `pystache`
+
+## Excel Schema Rules
+
+Each sheet must follow a strict schema for the first 5 rows:
+
+1.  **Row 1**: Column Description
+2.  **Row 2**: Usage / PrimaryKey indicator (`'PrimaryKey'` string marks it as primary)
+3.  **Row 3**: Attribute name
+4.  **Row 4**: Data Type
+5.  **Row 5**: Variable Name (the actual identifier used in the template)
+
+*Note: Sheets starting with an underscore (`_`) will be skipped.*
+
+## Usage
+
+Once installed, use the `pyexcel2mustache` command in your terminal:
+
+```bash
+pyexcel2mustache -i <input_excel> -t <template_mustache> -o <output_path> [-c]
+```
+
+### Arguments
+
+- `-i`, `--input`: Path to the input Excel file. (**Required**)
+- `-t`, `--template`: Path to the Mustache template file. (**Required**)
+- `-o`, `--output`: Path for the generated output file. (**Required**)
+- `-c`, `--clean`: Clean up/remove existing output file before writing.
+
+## Project Structure (Refactored)
+
+The project follows a modular structure:
+- `src/pyexcel2mustache/domain`: Data models.
+- `src/pyexcel2mustache/parsers`: Excel parsing logic.
+- `src/pyexcel2mustache/renderers`: Mustache rendering engine.
+- `src/pyexcel2mustache/cli`: Command line argument handling.

pyexcel2mustache-0.1.1/README.md

@@ -0,0 +1,64 @@
+# pyexcel2mustache
+
+Convert Excel (`xlsx`) sheets into Mustache templates based on a defined schema. This is now a distributable Python package.
+
+## Features
+
+- Convert multiple sheets at once using customizable schemas.
+- Skip sheets starting with an underscore (`_`).
+- Robust and modular architecture following SOLID principles.
+- Easy installation via `pip`.
+
+## Installation
+
+Install the package from the local directory:
+
+```bash
+pip install .
+```
+
+Once published to PyPI, you can install it using:
+
+```bash
+pip install pyexcel2mustache
+```
+
+## Requirements
+
+- Python 3.8+
+- Dependencies (automatically installed): `openpyxl`, `pystache`
+
+## Excel Schema Rules
+
+Each sheet must follow a strict schema for the first 5 rows:
+
+1.  **Row 1**: Column Description
+2.  **Row 2**: Usage / PrimaryKey indicator (`'PrimaryKey'` string marks it as primary)
+3.  **Row 3**: Attribute name
+4.  **Row 4**: Data Type
+5.  **Row 5**: Variable Name (the actual identifier used in the template)
+
+*Note: Sheets starting with an underscore (`_`) will be skipped.*
+
+## Usage
+
+Once installed, use the `pyexcel2mustache` command in your terminal:
+
+```bash
+pyexcel2mustache -i <input_excel> -t <template_mustache> -o <output_path> [-c]
+```
+
+### Arguments
+
+- `-i`, `--input`: Path to the input Excel file. (**Required**)
+- `-t`, `--template`: Path to the Mustache template file. (**Required**)
+- `-o`, `--output`: Path for the generated output file. (**Required**)
+- `-c`, `--clean`: Clean up/remove existing output file before writing.
+
+## Project Structure (Refactored)
+
+The project follows a modular structure:
+- `src/pyexcel2mustache/domain`: Data models.
+- `src/pyexcel2mustache/parsers`: Excel parsing logic.
+- `src/pyexcel2mustache/renderers`: Mustache rendering engine.
+- `src/pyexcel2mustache/cli`: Command line argument handling.

pyexcel2mustache-0.1.1/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyexcel2mustache"
+version = "0.1.1"
+description = "Convert Excel files to Mustache templates based on a defined schema."
+authors = [
+    {name = "oNsemy", email = "onsemy@gmail.com"}
+]
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "openpyxl>=3.1.0",
+    "pystache>=0.6.0"
+]
+
+[project.scripts]
+pyexcel2mustache = "pyexcel2mustache.main:run"

pyexcel2mustache-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyexcel2mustache-0.1.1/src/pyexcel2mustache/cli/args_parser.py

@@ -0,0 +1,28 @@
+import argparse
+
+
+def parse_arguments() -> argparse.Namespace:
+    """
+    Parses command-line arguments for the application.
+
+    Returns:
+        argparse.Namespace: An object containing the parsed arguments.
+    """
+    parser = argparse.ArgumentParser(
+        description="Convert Excel files to Mustache templates."
+    )
+    parser.add_argument(
+        "-i", "--input", help="Path of the input Excel file", required=True
+    )
+    parser.add_argument(
+        "-t", "--template", help="Path of the Mustache template file", required=True
+    )
+    parser.add_argument("-o", "--output", help="Path of the output file", required=True)
+    parser.add_argument(
+        "-c",
+        "--clean",
+        help="Clean up the output if it already exists",
+        action="store_true",
+    )
+
+    return parser.parse_args()

pyexcel2mustache-0.1.1/src/pyexcel2mustache/domain/models.py

@@ -0,0 +1,87 @@
+import datetime
+from typing import List
+
+
+class Attribute:
+    """Represents a single attribute within a class member."""
+
+    def __init__(self, name: str):
+        self._name = name
+
+    @property
+    def property(self) -> str:
+        return self._name
+
+
+class ClassMember:
+    """Represents a field or variable defined in the Excel schema."""
+
+    def __init__(
+        self,
+        attributes: List[Attribute],
+        data_type: str,
+        name: str,
+        is_primary_key: bool,
+    ):
+        self._attributes = attributes
+        self._type = data_type
+        self._name = name
+        self._is_primary_key = is_primary_key
+
+    @property
+    def type_name(self) -> str:
+        return self._type
+
+    @property
+    def var_name(self) -> str:
+        return self._name
+
+    @property
+    def attributes(self) -> List[Attribute]:
+        return self._attributes
+
+    @property
+    def IsPrimaryKey(self) -> bool:
+        return self._is_primary_key
+
+
+class ClassDeclare:
+    """Represents a fully defined class structure."""
+
+    def __init__(
+        self, name: str, date: datetime.datetime, class_members: List[ClassMember]
+    ):
+        self._name = name
+        self._date = date
+        self._classMembers = class_members
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def class_members(self) -> List[ClassMember]:
+        return self._classMembers
+
+    @property
+    def date(self) -> datetime.datetime:
+        return self._date
+
+
+class ClassList:
+    """A collection of defined classes, used for template rendering."""
+
+    def __init__(self, date: datetime.datetime):
+        self._class_list = []
+        self._date = date
+
+    def add(self, class_declare: ClassDeclare) -> None:
+        self._class_list.append(class_declare)
+
+    @property
+    def class_list(self) -> List[ClassDeclare]:
+        return self._class_list
+
+    @property
+    def date(self) -> datetime.datetime:
+        return self._date

pyexcel2mustache-0.1.1/src/pyexcel2mustache/main.py

@@ -0,0 +1,57 @@
+import os
+import logging
+from pyexcel2mustache.cli.args_parser import parse_arguments
+from pyexcel2mustache.parsers.excel_parser import ExcelParser
+from pyexcel2mustache.renderers.mustache_renderer import MustacheRenderer
+
+# Configure logger for the package
+logger = logging.getLogger("pyexcel2mustache")
+
+
+def run():
+    """
+    The main entry point for the excel2mustache CLI tool.
+    This function is called by the entry point defined in pyproject.toml.
+    """
+    args = parse_arguments()
+
+    if args.clean and os.path.exists(args.output):
+        os.remove(args.output)
+
+    try:
+        with open(args.template, "r") as f:
+            template_content = f.read()
+        if not template_content:
+            logger.error("Template file is empty.")
+            return
+    except Exception as e:
+        logger.error(f"Error reading template: {e}")
+        return
+
+    parser = ExcelParser()
+    try:
+        class_list = parser.parse(args.input)
+    except Exception as e:
+        logger.error(f"Error parsing Excel file: {e}")
+        return
+
+    renderer = MustacheRenderer()
+    try:
+        result = renderer.render(template_content, class_list)
+    except Exception as e:
+        logger.error(f"Error rendering template: {e}")
+        return
+
+    try:
+        with open(args.output, "w") as f:
+            f.write(result)
+        logger.info(f"Successfully generated: {args.output}")
+    except Exception as e:
+        logger.error(f"Error writing output file: {e}")
+        return
+
+
+if __name__ == "__main__":
+    # Default logging configuration for CLI usage
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+    run()

pyexcel2mustache-0.1.1/src/pyexcel2mustache/parsers/base_parser.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+from pyexcel2mustache.domain.models import ClassList
+
+
+class BaseParser(ABC):
+    """
+    Abstract base class for all parsers.
+    """
+
+    @abstractmethod
+    def parse(self, file_path: str) -> ClassList:
+        """
+        Parses a file and returns a ClassList object.
+
+        Args:
+            file_path (str): Path to the input file.
+
+        Returns:
+            ClassList: The parsed domain models.
+        """
+        pass

pyexcel2mustache-0.1.1/src/pyexcel2mustache/parsers/excel_parser.py

@@ -0,0 +1,92 @@
+import datetime
+from openpyxl import load_workbook
+from pyexcel2mustache.domain.models import (
+    ClassList,
+    ClassDeclare,
+    ClassMember,
+    Attribute,
+)
+from pyexcel2mustache.parsers.base_parser import BaseParser
+
+
+class ExcelParser(BaseParser):
+    """
+    A parser that reads Excel (.xlsx) files and converts them into domain models.
+    """
+
+    def parse(self, file_path: str) -> ClassList:
+        wb = load_workbook(filename=file_path, data_only=True)
+        class_list = ClassList(datetime.datetime.now())
+
+        for sheet in wb:
+            if sheet.title.startswith("_"):
+                continue
+
+            class_declare = self._parse_sheet(sheet)
+            if class_declare:
+                class_list.add(class_declare)
+
+        return class_list
+
+    def _parse_sheet(self, sheet) -> ClassDeclare:
+        # According to AGENTS.md requirements and original logic:
+        # Row 1 (idx 0): Column Description
+        # Row 2 (idx 1): Usage / PrimaryKey check ('PrimaryKey' string here)
+        # Row 3 (idx 2): Attribute (Not used for data, but part of schema)
+        # Row 4 (idx 3): Data Type
+        # Row 5 (idx 4): Variable Name
+
+        primary_index = -1
+        data_types = []
+        variable_names = []
+        attributes_list = []  # To hold the 'PrimaryKey' attribute if needed
+
+        # We need to iterate through rows or access them by index.
+        # Since it's a strict schema, we can use sheet.iter_rows()
+        # and check row indices (1-based). Or convert to list of rows.
+        rows = list(sheet.iter_rows())
+
+        if len(rows) < 5:
+            return None  # Sheet too small for the required schema
+
+        # Row 2 (idx 1): Find PrimaryKey index
+        row_2 = rows[1]
+        for idx, cell in enumerate(row_2):
+            if cell.value == "PrimaryKey":
+                primary_index = idx
+                break
+
+        # Row 4 (idx 3): Data Types
+        row_4 = rows[3]
+        for cell in row_4:
+            data_types.append(str(cell.value) if cell.value is not None else "")
+
+        # Row 5 (idx 4): Variable Names
+        row_5 = rows[4]
+        for cell in row_5:
+            variable_names.append(str(cell.value) if cell.value is not None else "")
+
+        class_members = []
+        # Iterate through the columns collected from data type and name rows
+        for i in range(len(data_types)):
+            if i >= len(variable_names):
+                break
+
+            name = variable_names[i]
+            dtype = data_types[i]
+
+            # Skip if no name is provided (treating it as end of columns)
+            if not name:
+                continue
+
+            is_primary = i == primary_index
+            attrs = []
+            if is_primary:
+                attrs.append(Attribute("PrimaryKey"))
+
+            member = ClassMember(
+                attributes=attrs, data_type=dtype, name=name, is_primary_key=is_primary
+            )
+            class_members.append(member)
+
+        return ClassDeclare(sheet.title, datetime.datetime.now(), class_members)

pyexcel2mustache-0.1.1/src/pyexcel2mustache/renderers/mustache_renderer.py

@@ -0,0 +1,21 @@
+import pystache
+from pyexcel2mustache.domain.models import ClassList
+
+
+class MustacheRenderer:
+    """
+    A renderer that uses Mustache templates to render domain models as strings.
+    """
+
+    def render(self, template_content: str, data: ClassList) -> str:
+        """
+        Renders the provided template content with the given data.
+
+        Args:
+            template_content (str): The mustache template string.
+            data (ClassList): The domain models to be rendered.
+
+        Returns:
+            str: The rendered output string.
+        """
+        return pystache.render(template_content, data)

pyexcel2mustache-0.1.1/src/pyexcel2mustache.egg-info/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: pyexcel2mustache
+Version: 0.1.1
+Summary: Convert Excel files to Mustache templates based on a defined schema.
+Author-email: oNsemy <onsemy@gmail.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: openpyxl>=3.1.0
+Requires-Dist: pystache>=0.6.0
+
+# pyexcel2mustache
+
+Convert Excel (`xlsx`) sheets into Mustache templates based on a defined schema. This is now a distributable Python package.
+
+## Features
+
+- Convert multiple sheets at once using customizable schemas.
+- Skip sheets starting with an underscore (`_`).
+- Robust and modular architecture following SOLID principles.
+- Easy installation via `pip`.
+
+## Installation
+
+Install the package from the local directory:
+
+```bash
+pip install .
+```
+
+Once published to PyPI, you can install it using:
+
+```bash
+pip install pyexcel2mustache
+```
+
+## Requirements
+
+- Python 3.8+
+- Dependencies (automatically installed): `openpyxl`, `pystache`
+
+## Excel Schema Rules
+
+Each sheet must follow a strict schema for the first 5 rows:
+
+1.  **Row 1**: Column Description
+2.  **Row 2**: Usage / PrimaryKey indicator (`'PrimaryKey'` string marks it as primary)
+3.  **Row 3**: Attribute name
+4.  **Row 4**: Data Type
+5.  **Row 5**: Variable Name (the actual identifier used in the template)
+
+*Note: Sheets starting with an underscore (`_`) will be skipped.*
+
+## Usage
+
+Once installed, use the `pyexcel2mustache` command in your terminal:
+
+```bash
+pyexcel2mustache -i <input_excel> -t <template_mustache> -o <output_path> [-c]
+```
+
+### Arguments
+
+- `-i`, `--input`: Path to the input Excel file. (**Required**)
+- `-t`, `--template`: Path to the Mustache template file. (**Required**)
+- `-o`, `--output`: Path for the generated output file. (**Required**)
+- `-c`, `--clean`: Clean up/remove existing output file before writing.
+
+## Project Structure (Refactored)
+
+The project follows a modular structure:
+- `src/pyexcel2mustache/domain`: Data models.
+- `src/pyexcel2mustache/parsers`: Excel parsing logic.
+- `src/pyexcel2mustache/renderers`: Mustache rendering engine.
+- `src/pyexcel2mustache/cli`: Command line argument handling.

pyexcel2mustache-0.1.1/src/pyexcel2mustache.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+src/pyexcel2mustache/__init__.py
+src/pyexcel2mustache/main.py
+src/pyexcel2mustache.egg-info/PKG-INFO
+src/pyexcel2mustache.egg-info/SOURCES.txt
+src/pyexcel2mustache.egg-info/dependency_links.txt
+src/pyexcel2mustache.egg-info/entry_points.txt
+src/pyexcel2mustache.egg-info/requires.txt
+src/pyexcel2mustache.egg-info/top_level.txt
+src/pyexcel2mustache/cli/__init__.py
+src/pyexcel2mustache/cli/args_parser.py
+src/pyexcel2mustache/domain/__init__.py
+src/pyexcel2mustache/domain/models.py
+src/pyexcel2mustache/parsers/__init__.py
+src/pyexcel2mustache/parsers/base_parser.py
+src/pyexcel2mustache/parsers/excel_parser.py
+src/pyexcel2mustache/renderers/__init__.py
+src/pyexcel2mustache/renderers/mustache_renderer.py

pyexcel2mustache-0.1.1/src/pyexcel2mustache.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyexcel2mustache-0.1.1/src/pyexcel2mustache.egg-info/entry_points.txt

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

pyexcel2mustache-0.1.1/src/pyexcel2mustache.egg-info/requires.txt

@@ -0,0 +1,2 @@
+openpyxl>=3.1.0
+pystache>=0.6.0

pyexcel2mustache-0.1.1/src/pyexcel2mustache.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyexcel2mustache