md-spreadsheet-parser 1.0.0

package/package.json

@@ -0,0 +1,36 @@
+{
+    "name": "md-spreadsheet-parser",
+    "version": "1.0.0",
+    "description": "A robust Markdown table parser and manipulator, powered by Python and WebAssembly.",
+    "main": "src/index.ts",
+    "types": "src/index.ts",
+    "type": "module",
+    "scripts": {
+        "build": "node scripts/build.mjs",
+        "test": "node scripts/test.mjs"
+    },
+    "files": [
+        "dist",
+        "src"
+    ],
+    "keywords": [
+        "markdown",
+        "spreadsheet",
+        "parser",
+        "wasm",
+        "webassembly",
+        "python"
+    ],
+    "author": "f-y",
+    "license": "MIT",
+    "devDependencies": {
+        "@bytecodealliance/jco": "^1.0.0",
+        "@bytecodealliance/preview2-shim": "^0.17.0",
+        "typescript": "^5.9.3",
+        "zod": "^4.3.4"
+    },
+    "dependencies": {
+        "execa": "^9.6.1",
+        "shelljs": "^0.10.0"
+    }
+}

package/src/app.py

@@ -0,0 +1,164 @@
+import md_spreadsheet_parser.parsing
+import md_spreadsheet_parser.generator
+import md_spreadsheet_parser.loader
+import dataclasses
+import json
+from typing import Any
+from generated_adapter import *
+
+class WitWorld:
+    def clean_cell(self, cell: Any = None, schema: Any = None):
+        kwargs = {}
+        if cell is not None: kwargs['cell'] = cell
+        if schema is not None: kwargs['schema'] = unwrap_parsing_schema(schema)
+        return md_spreadsheet_parser.parsing.clean_cell(**kwargs)
+    def split_row_gfm(self, line: Any = None, separator: Any = None):
+        kwargs = {}
+        if line is not None: kwargs['line'] = line
+        if separator is not None: kwargs['separator'] = separator
+        return md_spreadsheet_parser.parsing.split_row_gfm(**kwargs)
+    def parse_row(self, line: Any = None, schema: Any = None):
+        kwargs = {}
+        if line is not None: kwargs['line'] = line
+        if schema is not None: kwargs['schema'] = unwrap_parsing_schema(schema)
+        return md_spreadsheet_parser.parsing.parse_row(**kwargs)
+    def parse_separator_row(self, row: Any = None, schema: Any = None):
+        kwargs = {}
+        if row is not None: kwargs['row'] = row
+        if schema is not None: kwargs['schema'] = unwrap_parsing_schema(schema)
+        return [convert_alignment_type(x) for x in md_spreadsheet_parser.parsing.parse_separator_row(**kwargs)]
+    def is_separator_row(self, row: Any = None, schema: Any = None):
+        kwargs = {}
+        if row is not None: kwargs['row'] = row
+        if schema is not None: kwargs['schema'] = unwrap_parsing_schema(schema)
+        return md_spreadsheet_parser.parsing.is_separator_row(**kwargs)
+    def parse_table(self, markdown: Any = None, schema: Any = None):
+        kwargs = {}
+        if markdown is not None: kwargs['markdown'] = markdown
+        if schema is not None: kwargs['schema'] = unwrap_parsing_schema(schema)
+        return convert_table(md_spreadsheet_parser.parsing.parse_table(**kwargs))
+    def parse_sheet(self, markdown: Any = None, name: Any = None, schema: Any = None, start_line_offset: Any = None):
+        kwargs = {}
+        if markdown is not None: kwargs['markdown'] = markdown
+        if name is not None: kwargs['name'] = name
+        if schema is not None: kwargs['schema'] = unwrap_multi_table_parsing_schema(schema)
+        if start_line_offset is not None: kwargs['start_line_offset'] = start_line_offset
+        return convert_sheet(md_spreadsheet_parser.parsing.parse_sheet(**kwargs))
+    def parse_workbook(self, markdown: Any = None, schema: Any = None):
+        kwargs = {}
+        if markdown is not None: kwargs['markdown'] = markdown
+        if schema is not None: kwargs['schema'] = unwrap_multi_table_parsing_schema(schema)
+        return convert_workbook(md_spreadsheet_parser.parsing.parse_workbook(**kwargs))
+    def scan_tables(self, markdown: Any = None, schema: Any = None):
+        kwargs = {}
+        if markdown is not None: kwargs['markdown'] = markdown
+        if schema is not None: kwargs['schema'] = unwrap_multi_table_parsing_schema(schema)
+        return [convert_table(x) for x in md_spreadsheet_parser.parsing.scan_tables(**kwargs)]
+    def generate_table_markdown(self, table: Any = None, schema: Any = None):
+        kwargs = {}
+        if table is not None: kwargs['table'] = unwrap_table(table)
+        if schema is not None: kwargs['schema'] = unwrap_parsing_schema(schema)
+        return md_spreadsheet_parser.generator.generate_table_markdown(**kwargs)
+    def generate_sheet_markdown(self, sheet: Any = None, schema: Any = None):
+        kwargs = {}
+        if sheet is not None: kwargs['sheet'] = unwrap_sheet(sheet)
+        if schema is not None: kwargs['schema'] = unwrap_parsing_schema(schema)
+        return md_spreadsheet_parser.generator.generate_sheet_markdown(**kwargs)
+    def generate_workbook_markdown(self, workbook: Any = None, schema: Any = None):
+        kwargs = {}
+        if workbook is not None: kwargs['workbook'] = unwrap_workbook(workbook)
+        if schema is not None: kwargs['schema'] = unwrap_multi_table_parsing_schema(schema)
+        return md_spreadsheet_parser.generator.generate_workbook_markdown(**kwargs)
+    def parse_table_from_file(self, source: Any = None, schema: Any = None):
+        kwargs = {}
+        if source is not None: kwargs['source'] = source
+        if schema is not None: kwargs['schema'] = unwrap_parsing_schema(schema)
+        return convert_table(md_spreadsheet_parser.loader.parse_table_from_file(**kwargs))
+    def parse_workbook_from_file(self, source: Any = None, schema: Any = None):
+        kwargs = {}
+        if source is not None: kwargs['source'] = source
+        if schema is not None: kwargs['schema'] = unwrap_multi_table_parsing_schema(schema)
+        return convert_workbook(md_spreadsheet_parser.loader.parse_workbook_from_file(**kwargs))
+    def scan_tables_from_file(self, source: Any = None, schema: Any = None):
+        kwargs = {}
+        if source is not None: kwargs['source'] = source
+        if schema is not None: kwargs['schema'] = unwrap_multi_table_parsing_schema(schema)
+        return [convert_table(x) for x in md_spreadsheet_parser.loader.scan_tables_from_file(**kwargs)]
+    def scan_tables_iter(self, source: Any = None, schema: Any = None):
+        kwargs = {}
+        if source is not None: kwargs['source'] = source
+        if schema is not None: kwargs['schema'] = unwrap_multi_table_parsing_schema(schema)
+        return str(md_spreadsheet_parser.loader.scan_tables_iter(**kwargs))
+    def table_to_models(self, self_obj: Any, schema_cls: Any = None, conversion_schema: Any = None):
+        real_self = unwrap_table(self_obj)
+        kwargs = {}
+        if schema_cls is not None: kwargs['schema_cls'] = resolve_model_class(schema_cls)
+        if conversion_schema is not None: kwargs['conversion_schema'] = unwrap_conversion_schema(conversion_schema)
+        return [json.dumps(dataclasses.asdict(x)) for x in real_self.to_models(**kwargs)]
+    def table_to_markdown(self, self_obj: Any, schema: Any = None):
+        real_self = unwrap_table(self_obj)
+        kwargs = {}
+        if schema is not None: kwargs['schema'] = unwrap_parsing_schema(schema)
+        return real_self.to_markdown(**kwargs)
+    def table_update_cell(self, self_obj: Any, row_idx: Any = None, col_idx: Any = None, value: Any = None):
+        real_self = unwrap_table(self_obj)
+        kwargs = {}
+        if row_idx is not None: kwargs['row_idx'] = row_idx
+        if col_idx is not None: kwargs['col_idx'] = col_idx
+        if value is not None: kwargs['value'] = value
+        return convert_table(real_self.update_cell(**kwargs))
+    def table_delete_row(self, self_obj: Any, row_idx: Any = None):
+        real_self = unwrap_table(self_obj)
+        kwargs = {}
+        if row_idx is not None: kwargs['row_idx'] = row_idx
+        return convert_table(real_self.delete_row(**kwargs))
+    def table_delete_column(self, self_obj: Any, col_idx: Any = None):
+        real_self = unwrap_table(self_obj)
+        kwargs = {}
+        if col_idx is not None: kwargs['col_idx'] = col_idx
+        return convert_table(real_self.delete_column(**kwargs))
+    def table_clear_column_data(self, self_obj: Any, col_idx: Any = None):
+        real_self = unwrap_table(self_obj)
+        kwargs = {}
+        if col_idx is not None: kwargs['col_idx'] = col_idx
+        return convert_table(real_self.clear_column_data(**kwargs))
+    def table_insert_row(self, self_obj: Any, row_idx: Any = None):
+        real_self = unwrap_table(self_obj)
+        kwargs = {}
+        if row_idx is not None: kwargs['row_idx'] = row_idx
+        return convert_table(real_self.insert_row(**kwargs))
+    def table_insert_column(self, self_obj: Any, col_idx: Any = None):
+        real_self = unwrap_table(self_obj)
+        kwargs = {}
+        if col_idx is not None: kwargs['col_idx'] = col_idx
+        return convert_table(real_self.insert_column(**kwargs))
+    def sheet_get_table(self, self_obj: Any, name: Any = None):
+        real_self = unwrap_sheet(self_obj)
+        kwargs = {}
+        if name is not None: kwargs['name'] = name
+        return convert_table(real_self.get_table(**kwargs))
+    def sheet_to_markdown(self, self_obj: Any, schema: Any = None):
+        real_self = unwrap_sheet(self_obj)
+        kwargs = {}
+        if schema is not None: kwargs['schema'] = unwrap_parsing_schema(schema)
+        return real_self.to_markdown(**kwargs)
+    def workbook_get_sheet(self, self_obj: Any, name: Any = None):
+        real_self = unwrap_workbook(self_obj)
+        kwargs = {}
+        if name is not None: kwargs['name'] = name
+        return convert_sheet(real_self.get_sheet(**kwargs))
+    def workbook_to_markdown(self, self_obj: Any, schema: Any = None):
+        real_self = unwrap_workbook(self_obj)
+        kwargs = {}
+        if schema is not None: kwargs['schema'] = unwrap_multi_table_parsing_schema(schema)
+        return real_self.to_markdown(**kwargs)
+    def workbook_add_sheet(self, self_obj: Any, name: Any = None):
+        real_self = unwrap_workbook(self_obj)
+        kwargs = {}
+        if name is not None: kwargs['name'] = name
+        return convert_workbook(real_self.add_sheet(**kwargs))
+    def workbook_delete_sheet(self, self_obj: Any, index: Any = None):
+        real_self = unwrap_workbook(self_obj)
+        kwargs = {}
+        if index is not None: kwargs['index'] = index
+        return convert_workbook(real_self.delete_sheet(**kwargs))

package/src/client-adapters.ts

@@ -0,0 +1,40 @@
+
+export function clientSideToModels(headers: string[] | undefined | null, rows: any[][], schemaCls: any): any[] | null {
+    // Client-Side Schema Support
+    if (typeof schemaCls === 'object' && schemaCls !== null) {
+        if (!headers) throw new Error('Table must have headers for client-side mapping');
+        if (!rows) throw new Error('Table has no rows');
+
+        // 1. Zod-like Schema (has .parse method)
+        if (typeof (schemaCls as any).parse === 'function') {
+            return rows.map((row: any) => {
+                const rawObj: any = {};
+                row.forEach((v: string, i: number) => {
+                    if (headers && headers[i]) {
+                        rawObj[headers[i]] = v;
+                    }
+                });
+                return (schemaCls as any).parse(rawObj);
+            });
+        }
+
+        // 2. Object Mapping Schema
+        return rows.map((row: any) => {
+            const obj: any = {};
+            row.forEach((v: string, i: number) => {
+                const h = headers ? headers[i] : undefined;
+                if (h) {
+                    if (schemaCls[h] && typeof schemaCls[h] === 'function') {
+                        obj[h] = schemaCls[h](v);
+                    } else {
+                        obj[h] = v;
+                    }
+                }
+            });
+            return obj;
+        });
+    }
+
+    // Return null to indicate fallthrough to WASM backend
+    return null;
+}

package/src/generated_adapter.py

@@ -0,0 +1,247 @@
+import json
+from dataclasses import dataclass, asdict
+from typing import Any
+import md_spreadsheet_parser.models as models
+import md_spreadsheet_parser.schemas as schemas
+
+def resolve_model_class(name: str) -> Any:
+    cls = None
+    if hasattr(models, name):
+        cls = getattr(models, name)
+    elif hasattr(schemas, name):
+        cls = getattr(schemas, name)
+    if cls:
+        return cls
+    raise ValueError(f'Unknown model/schema class: {name}')
+
+def convert_alignment_type(val: str) -> str:
+    # Return string directly as WIT type is string
+    return val
+
+@dataclass
+class WitTable:
+    headers: Any = None
+    rows: Any = None
+    alignments: Any = None
+    name: Any = None
+    description: Any = None
+    metadata: Any = None
+    start_line: Any = None
+    end_line: Any = None
+
+def convert_table(obj: Any) -> WitTable:
+    if obj is None: return None
+    res = WitTable()
+    res.headers = obj.headers
+    res.rows = obj.rows
+    res.alignments = [convert_alignment_type(x) for x in obj.alignments] if obj.alignments is not None else None
+    res.name = obj.name
+    res.description = obj.description
+    res.metadata = json.dumps(obj.metadata or {}) if obj.metadata is not None else None
+    res.start_line = obj.start_line
+    res.end_line = obj.end_line
+    return res
+
+def unwrap_table(obj: Any) -> Any:
+    if obj is None: return None
+    kwargs = {}
+    if obj.headers is not None:
+        kwargs['headers'] = obj.headers
+    if obj.rows is not None:
+        kwargs['rows'] = obj.rows
+    if obj.alignments is not None:
+        kwargs['alignments'] = obj.alignments
+    if obj.name is not None:
+        kwargs['name'] = obj.name
+    if obj.description is not None:
+        kwargs['description'] = obj.description
+    if obj.metadata is not None:
+        kwargs['metadata'] = json.loads(obj.metadata)
+    if obj.start_line is not None:
+        kwargs['start_line'] = obj.start_line
+    if obj.end_line is not None:
+        kwargs['end_line'] = obj.end_line
+    return models.Table(**kwargs)
+
+@dataclass
+class WitSheet:
+    name: Any = None
+    tables: Any = None
+    metadata: Any = None
+
+def convert_sheet(obj: Any) -> WitSheet:
+    if obj is None: return None
+    res = WitSheet()
+    res.name = obj.name
+    res.tables = [convert_table(x) for x in obj.tables]
+    res.metadata = json.dumps(obj.metadata or {}) if obj.metadata is not None else None
+    return res
+
+def unwrap_sheet(obj: Any) -> Any:
+    if obj is None: return None
+    kwargs = {}
+    if obj.name is not None:
+        kwargs['name'] = obj.name
+    if obj.tables is not None:
+        kwargs['tables'] = [unwrap_table(x) for x in obj.tables]
+    if obj.metadata is not None:
+        kwargs['metadata'] = json.loads(obj.metadata)
+    return models.Sheet(**kwargs)
+
+@dataclass
+class WitWorkbook:
+    sheets: Any = None
+    metadata: Any = None
+
+def convert_workbook(obj: Any) -> WitWorkbook:
+    if obj is None: return None
+    res = WitWorkbook()
+    res.sheets = [convert_sheet(x) for x in obj.sheets]
+    res.metadata = json.dumps(obj.metadata or {}) if obj.metadata is not None else None
+    return res
+
+def unwrap_workbook(obj: Any) -> Any:
+    if obj is None: return None
+    kwargs = {}
+    if obj.sheets is not None:
+        kwargs['sheets'] = [unwrap_sheet(x) for x in obj.sheets]
+    if obj.metadata is not None:
+        kwargs['metadata'] = json.loads(obj.metadata)
+    return models.Workbook(**kwargs)
+
+@dataclass
+class WitParsingSchema:
+    column_separator: Any = None
+    header_separator_char: Any = None
+    require_outer_pipes: Any = None
+    strip_whitespace: Any = None
+    convert_br_to_newline: Any = None
+
+def convert_parsing_schema(obj: Any) -> WitParsingSchema:
+    if obj is None: return None
+    res = WitParsingSchema()
+    res.column_separator = obj.column_separator
+    res.header_separator_char = obj.header_separator_char
+    res.require_outer_pipes = obj.require_outer_pipes
+    res.strip_whitespace = obj.strip_whitespace
+    res.convert_br_to_newline = obj.convert_br_to_newline
+    return res
+
+def unwrap_parsing_schema(obj: Any) -> Any:
+    if obj is None: return None
+    kwargs = {}
+    if obj.column_separator is not None:
+        kwargs['column_separator'] = obj.column_separator
+    if obj.header_separator_char is not None:
+        kwargs['header_separator_char'] = obj.header_separator_char
+    if obj.require_outer_pipes is not None:
+        kwargs['require_outer_pipes'] = obj.require_outer_pipes
+    if obj.strip_whitespace is not None:
+        kwargs['strip_whitespace'] = obj.strip_whitespace
+    if obj.convert_br_to_newline is not None:
+        kwargs['convert_br_to_newline'] = obj.convert_br_to_newline
+    return schemas.ParsingSchema(**kwargs)
+
+@dataclass
+class WitMultiTableParsingSchema:
+    column_separator: Any = None
+    header_separator_char: Any = None
+    require_outer_pipes: Any = None
+    strip_whitespace: Any = None
+    convert_br_to_newline: Any = None
+    root_marker: Any = None
+    sheet_header_level: Any = None
+    table_header_level: Any = None
+    capture_description: Any = None
+
+def convert_multi_table_parsing_schema(obj: Any) -> WitMultiTableParsingSchema:
+    if obj is None: return None
+    res = WitMultiTableParsingSchema()
+    res.column_separator = obj.column_separator
+    res.header_separator_char = obj.header_separator_char
+    res.require_outer_pipes = obj.require_outer_pipes
+    res.strip_whitespace = obj.strip_whitespace
+    res.convert_br_to_newline = obj.convert_br_to_newline
+    res.root_marker = obj.root_marker
+    res.sheet_header_level = obj.sheet_header_level
+    res.table_header_level = obj.table_header_level
+    res.capture_description = obj.capture_description
+    return res
+
+def unwrap_multi_table_parsing_schema(obj: Any) -> Any:
+    if obj is None: return None
+    kwargs = {}
+    if obj.column_separator is not None:
+        kwargs['column_separator'] = obj.column_separator
+    if obj.header_separator_char is not None:
+        kwargs['header_separator_char'] = obj.header_separator_char
+    if obj.require_outer_pipes is not None:
+        kwargs['require_outer_pipes'] = obj.require_outer_pipes
+    if obj.strip_whitespace is not None:
+        kwargs['strip_whitespace'] = obj.strip_whitespace
+    if obj.convert_br_to_newline is not None:
+        kwargs['convert_br_to_newline'] = obj.convert_br_to_newline
+    if obj.root_marker is not None:
+        kwargs['root_marker'] = obj.root_marker
+    if obj.sheet_header_level is not None:
+        kwargs['sheet_header_level'] = obj.sheet_header_level
+    if obj.table_header_level is not None:
+        kwargs['table_header_level'] = obj.table_header_level
+    if obj.capture_description is not None:
+        kwargs['capture_description'] = obj.capture_description
+    return schemas.MultiTableParsingSchema(**kwargs)
+
+@dataclass
+class WitConversionSchema:
+    boolean_pairs: Any = None
+    custom_converters: Any = None
+    field_converters: Any = None
+
+def convert_conversion_schema(obj: Any) -> WitConversionSchema:
+    if obj is None: return None
+    res = WitConversionSchema()
+    res.boolean_pairs = str(obj.boolean_pairs) if obj.boolean_pairs is not None else None
+    res.custom_converters = json.dumps(obj.custom_converters or {}) if obj.custom_converters is not None else None
+    res.field_converters = json.dumps(obj.field_converters or {}) if obj.field_converters is not None else None
+    return res
+
+def unwrap_conversion_schema(obj: Any) -> Any:
+    if obj is None: return None
+    kwargs = {}
+    if obj.boolean_pairs is not None:
+        kwargs['boolean_pairs'] = obj.boolean_pairs
+    if obj.custom_converters is not None:
+        kwargs['custom_converters'] = json.loads(obj.custom_converters)
+    if obj.field_converters is not None:
+        kwargs['field_converters'] = json.loads(obj.field_converters)
+    return schemas.ConversionSchema(**kwargs)
+
+@dataclass
+class WitExcelParsingSchema:
+    header_rows: Any = None
+    fill_merged_headers: Any = None
+    delimiter: Any = None
+    header_separator: Any = None
+
+def convert_excel_parsing_schema(obj: Any) -> WitExcelParsingSchema:
+    if obj is None: return None
+    res = WitExcelParsingSchema()
+    res.header_rows = obj.header_rows
+    res.fill_merged_headers = obj.fill_merged_headers
+    res.delimiter = obj.delimiter
+    res.header_separator = obj.header_separator
+    return res
+
+def unwrap_excel_parsing_schema(obj: Any) -> Any:
+    if obj is None: return None
+    kwargs = {}
+    if obj.header_rows is not None:
+        kwargs['header_rows'] = obj.header_rows
+    if obj.fill_merged_headers is not None:
+        kwargs['fill_merged_headers'] = obj.fill_merged_headers
+    if obj.delimiter is not None:
+        kwargs['delimiter'] = obj.delimiter
+    if obj.header_separator is not None:
+        kwargs['header_separator'] = obj.header_separator
+    return schemas.ExcelParsingSchema(**kwargs)
+