mtchart-sdk 0.1.0__py3-none-any.whl

mtchart_sdk/__init__.py

@@ -0,0 +1,31 @@
+from mtchart_sdk.models import (
+    PartItem,
+    PenConfig,
+    ProcessInput,
+    ProcessRecord,
+    ReadingEvaluation,
+)
+from mtchart_sdk.rules import (
+    calculate_exit_timing,
+    clean_identifier,
+    evaluate_temperature,
+    normalize_item,
+    total_quantity,
+)
+from mtchart_sdk.service import MTChartService
+from mtchart_sdk.storage import PartsCatalog
+
+__all__ = [
+    "MTChartService",
+    "PartItem",
+    "PartsCatalog",
+    "PenConfig",
+    "ProcessInput",
+    "ProcessRecord",
+    "ReadingEvaluation",
+    "calculate_exit_timing",
+    "clean_identifier",
+    "evaluate_temperature",
+    "normalize_item",
+    "total_quantity",
+]

mtchart_sdk/cli.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import argparse
+import json
+from datetime import datetime
+from pathlib import Path
+
+from mtchart_sdk.models import PartItem, PenConfig, ProcessInput
+from mtchart_sdk.service import MTChartService
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="mtchart-sdk-demo",
+        description="Executa uma demonstracao local do MTChart SDK.",
+    )
+    parser.add_argument("--catalog-db", default="mtchart_sdk_demo.db", help="Caminho do catalogo SQLite.")
+    parser.add_argument("--report-number", default="CH-DEMO-001", help="Numero do relatorio.")
+    parser.add_argument("--project", default="OS-DEMO", help="Projeto ou ordem de servico.")
+    parser.add_argument("--process-name", default="Alivio de fragilizacao", help="Nome do processo.")
+    parser.add_argument("--oven", default="Forno Demo", help="Nome do forno.")
+    parser.add_argument("--relief-hours", type=float, default=3.0, help="Horas de permanencia do processo.")
+    parser.add_argument("--pen-id", default="1", help="Identificador da pena.")
+    parser.add_argument("--target", type=float, default=189.0, help="Temperatura alvo para iniciar processo.")
+    parser.add_argument("--low-limit", type=float, default=175.9, help="Limite inferior de temperatura.")
+    parser.add_argument("--high-limit", type=float, default=220.0, help="Limite superior de temperatura.")
+    parser.add_argument("--value", default="188.7", help="Leitura de temperatura a avaliar.")
+    parser.add_argument("--part-name", default="Suporte Demo", help="Nome da peca.")
+    parser.add_argument("--pn", default="PN-DEMO-001", help="Part number da peca.")
+    parser.add_argument("--sn", default="SN-DEMO-001", help="Serial number da peca.")
+    parser.add_argument("--qty", type=int, default=1, help="Quantidade da peca.")
+    return parser
+
+
+def run_demo(args: argparse.Namespace) -> dict[str, object]:
+    service = MTChartService(catalog_db=Path(args.catalog_db))
+    started_at = datetime.now().replace(microsecond=0)
+    process = service.create_process(
+        ProcessInput(
+            report_number=args.report_number,
+            project=args.project,
+            process_name=args.process_name,
+            oven=args.oven,
+            relief_hours=args.relief_hours,
+            pen=PenConfig(
+                id=args.pen_id,
+                name=f"Pena {args.pen_id}",
+                stabilization_target=args.target,
+                low_limit=args.low_limit,
+                high_limit=args.high_limit,
+            ),
+            items=[
+                PartItem(
+                    name=args.part_name,
+                    pn=args.pn,
+                    sn=args.sn,
+                    qty=args.qty,
+                )
+            ],
+            started_at=started_at,
+        )
+    )
+    reading = service.evaluate_reading(process, args.value, now=started_at)
+    return {
+        "report_number": process.report_number,
+        "project": process.project,
+        "expected_exit_at": process.expected_exit_at.isoformat(),
+        "total_quantity": process.total_quantity,
+        "reading": {
+            "value": reading.value,
+            "status": reading.status,
+            "can_start_process": reading.can_start_process,
+            "remaining_seconds": reading.remaining_seconds,
+        },
+        "catalog_matches": service.search_parts(args.pn, limit=5),
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    result = run_demo(parser.parse_args(argv))
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mtchart_sdk/models.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any
+
+
+@dataclass(frozen=True)
+class PartItem:
+    name: str = ""
+    pn: str = ""
+    sn: str = ""
+    qty: int = 1
+    project: str = ""
+
+
+@dataclass(frozen=True)
+class PenConfig:
+    id: str
+    name: str = ""
+    stabilization_target: float | None = None
+    low_limit: float | None = None
+    high_limit: float | None = None
+    tolerance: float = 0.5
+
+
+@dataclass(frozen=True)
+class ProcessInput:
+    report_number: str
+    project: str
+    process_name: str
+    oven: str
+    relief_hours: float
+    pen: PenConfig
+    items: list[PartItem | dict[str, Any]] = field(default_factory=list)
+    started_at: datetime | None = None
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class ProcessRecord:
+    report_number: str
+    project: str
+    process_name: str
+    oven: str
+    relief_hours: float
+    pen: PenConfig
+    items: list[PartItem]
+    started_at: datetime
+    expected_exit_at: datetime
+    total_quantity: int
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class ReadingEvaluation:
+    value: float | None
+    status: str
+    is_numeric: bool
+    is_within_limits: bool
+    is_low_temperature: bool
+    can_start_process: bool
+    remaining_seconds: float

mtchart_sdk/rules.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import re
+from datetime import datetime, timedelta
+from typing import Any
+
+from mtchart_sdk.models import PartItem, PenConfig, ReadingEvaluation
+
+
+def to_float_or_none(value: Any) -> float | None:
+    try:
+        if value in ("", None):
+            return None
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def clean_identifier(value: Any) -> str:
+    text = str(value or "").strip()
+    return re.sub(r"^\s*(PN|P/N|LOTE|BATCH)\s*:\s*", "", text, flags=re.IGNORECASE).strip()
+
+
+def normalize_item(item: PartItem | dict[str, Any] | str) -> PartItem:
+    if isinstance(item, PartItem):
+        return item
+    if isinstance(item, dict):
+        try:
+            qty = max(1, int(str(item.get("qty", 1)).strip() or "1"))
+        except (TypeError, ValueError):
+            qty = 1
+        return PartItem(
+            name=str(item.get("name", item.get("nome", ""))).strip(),
+            pn=clean_identifier(item.get("pn", "")),
+            sn=str(item.get("sn", "")).strip(),
+            qty=qty,
+            project=str(item.get("project", item.get("projeto", ""))).strip(),
+        )
+    return PartItem(sn=str(item or "").strip())
+
+
+def total_quantity(items: list[PartItem | dict[str, Any] | str]) -> int:
+    return sum(normalize_item(item).qty for item in items or [])
+
+
+def calculate_exit_timing(started_at: datetime, relief_hours: float, now: datetime | None = None) -> tuple[datetime, float]:
+    now = now or datetime.now()
+    expected_exit_at = started_at + timedelta(hours=float(relief_hours or 0))
+    return expected_exit_at, (expected_exit_at - now).total_seconds()
+
+
+def evaluate_temperature(
+    value: Any,
+    pen: PenConfig,
+    started_at: datetime,
+    relief_hours: float,
+    now: datetime | None = None,
+) -> ReadingEvaluation:
+    numeric_value = to_float_or_none(value)
+    expected_exit_at, remaining_seconds = calculate_exit_timing(started_at, relief_hours, now)
+    del expected_exit_at
+
+    if numeric_value is None:
+        return ReadingEvaluation(
+            value=None,
+            status="N/A",
+            is_numeric=False,
+            is_within_limits=False,
+            is_low_temperature=False,
+            can_start_process=False,
+            remaining_seconds=remaining_seconds,
+        )
+
+    low_limit = pen.low_limit
+    high_limit = pen.high_limit
+    has_low = low_limit is not None
+    has_high = high_limit is not None
+    is_low = has_low and numeric_value < float(low_limit)
+    is_high = has_high and numeric_value > float(high_limit)
+    is_within = not is_low and not is_high
+    target = pen.stabilization_target
+    can_start = target is not None and numeric_value >= float(target) - float(pen.tolerance)
+
+    if is_low:
+        status = "LOW"
+    elif is_high:
+        status = "HIGH"
+    elif is_within:
+        status = "OK"
+    else:
+        status = "UNKNOWN"
+
+    return ReadingEvaluation(
+        value=numeric_value,
+        status=status,
+        is_numeric=True,
+        is_within_limits=is_within,
+        is_low_temperature=is_low,
+        can_start_process=can_start,
+        remaining_seconds=remaining_seconds,
+    )

mtchart_sdk/service.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+from mtchart_sdk.models import PartItem, ProcessInput, ProcessRecord, ReadingEvaluation
+from mtchart_sdk.rules import calculate_exit_timing, evaluate_temperature, normalize_item, total_quantity
+from mtchart_sdk.storage import PartsCatalog
+
+
+class MTChartService:
+    def __init__(self, catalog_db: str | Path | None = None) -> None:
+        self.catalog = PartsCatalog(catalog_db or "mtchart_sdk.db")
+
+    def create_process(self, data: ProcessInput) -> ProcessRecord:
+        started_at = data.started_at or datetime.now()
+        items = [normalize_item(item) for item in data.items]
+        for item in items:
+            if item.name and item.pn:
+                self.catalog.save(item.name, item.pn)
+        expected_exit_at, _remaining = calculate_exit_timing(started_at, data.relief_hours, started_at)
+        return ProcessRecord(
+            report_number=data.report_number,
+            project=data.project,
+            process_name=data.process_name,
+            oven=data.oven,
+            relief_hours=float(data.relief_hours or 0),
+            pen=data.pen,
+            items=items,
+            started_at=started_at,
+            expected_exit_at=expected_exit_at,
+            total_quantity=total_quantity(items),
+            metadata=dict(data.metadata or {}),
+        )
+
+    def evaluate_reading(
+        self,
+        process: ProcessRecord,
+        value: float | str | None,
+        now: datetime | None = None,
+    ) -> ReadingEvaluation:
+        return evaluate_temperature(
+            value=value,
+            pen=process.pen,
+            started_at=process.started_at,
+            relief_hours=process.relief_hours,
+            now=now,
+        )
+
+    def search_parts(self, term: str = "", limit: int = 100) -> list[dict[str, object]]:
+        return self.catalog.search(term, limit)

mtchart_sdk/storage.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import sqlite3
+from contextlib import contextmanager
+from datetime import datetime
+from pathlib import Path
+from typing import Iterator
+
+from mtchart_sdk.rules import clean_identifier
+
+
+class PartsCatalog:
+    def __init__(self, db_path: str | Path = "mtchart_sdk.db") -> None:
+        self.db_path = Path(db_path)
+        if self.db_path.parent != Path("."):
+            self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self.init_db()
+
+    @contextmanager
+    def connect(self) -> Iterator[sqlite3.Connection]:
+        conn = sqlite3.connect(self.db_path)
+        try:
+            yield conn
+            conn.commit()
+        except Exception:
+            conn.rollback()
+            raise
+        finally:
+            conn.close()
+
+    def init_db(self) -> None:
+        with self.connect() as conn:
+            conn.execute(
+                """
+                CREATE TABLE IF NOT EXISTS catalog_parts (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    name TEXT NOT NULL,
+                    pn TEXT NOT NULL,
+                    name_norm TEXT NOT NULL,
+                    pn_norm TEXT NOT NULL,
+                    use_count INTEGER DEFAULT 1,
+                    last_used_at TEXT NOT NULL,
+                    UNIQUE(name_norm, pn_norm)
+                )
+                """
+            )
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_catalog_parts_name ON catalog_parts(name_norm)")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_catalog_parts_pn ON catalog_parts(pn_norm)")
+
+    def save(self, name: str, pn: str, increment: bool = True) -> None:
+        name = clean_identifier(name)
+        pn = clean_identifier(pn)
+        if not name or not pn:
+            raise ValueError("name and pn are required")
+        name_norm = name.upper()
+        pn_norm = pn.upper()
+        increment_by = 1 if increment else 0
+        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        with self.connect() as conn:
+            conn.execute(
+                """
+                INSERT INTO catalog_parts (name, pn, name_norm, pn_norm, use_count, last_used_at)
+                VALUES (?, ?, ?, ?, 1, ?)
+                ON CONFLICT(name_norm, pn_norm) DO UPDATE SET
+                    name = excluded.name,
+                    pn = excluded.pn,
+                    use_count = catalog_parts.use_count + ?,
+                    last_used_at = excluded.last_used_at
+                """,
+                (name, pn, name_norm, pn_norm, now, increment_by),
+            )
+
+    def search(self, term: str = "", limit: int = 100) -> list[dict[str, object]]:
+        term_norm = clean_identifier(term).upper()
+        limit = max(1, min(1000, int(limit or 100)))
+        query = """
+            SELECT id, name, pn, use_count, last_used_at
+            FROM catalog_parts
+        """
+        params: tuple[object, ...]
+        if term_norm:
+            query += " WHERE name_norm LIKE ? OR pn_norm LIKE ?"
+            params = (f"%{term_norm}%", f"%{term_norm}%", limit)
+        else:
+            params = (limit,)
+        query += " ORDER BY use_count DESC, id DESC LIMIT ?"
+        with self.connect() as conn:
+            rows = conn.execute(query, params).fetchall()
+        return [
+            {
+                "id": row[0],
+                "name": row[1],
+                "pn": row[2],
+                "use_count": row[3],
+                "last_used_at": row[4],
+            }
+            for row in rows
+        ]

mtchart_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: mtchart-sdk
+Version: 0.1.0
+Summary: SDK para criar sistemas de monitoramento termico, rastreabilidade e relatorios derivados do MTChart Pro.
+Author: MTD Softwares
+License-Expression: LicenseRef-Proprietary
+Project-URL: Homepage, https://github.com/Romero-Softwares/mtchart_sdk
+Project-URL: Repository, https://github.com/Romero-Softwares/mtchart_sdk
+Project-URL: Documentation, https://github.com/Romero-Softwares/mtchart_sdk#readme
+Project-URL: Issues, https://github.com/Romero-Softwares/mtchart_sdk/issues
+Keywords: monitoramento,processo-termico,rastreabilidade,aviacao,industrial
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Provides-Extra: reports
+Requires-Dist: openpyxl>=3.1; extra == "reports"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# MTChart SDK
+
+SDK inicial para desenvolvedores criarem sistemas semelhantes ao MTChart Pro usando classes e metodos reutilizaveis.
+
+Esta primeira versao fica separada do aplicativo desktop e entrega um nucleo limpo para:
+
+- cadastrar processos termicos;
+- validar leituras de temperatura;
+- calcular previsao de saida;
+- registrar catalogo local de pecas e PN;
+- montar dados de rastreabilidade sem depender da interface Flet.
+
+## Instalacao
+
+```powershell
+python -m pip install mtchart-sdk
+```
+
+## Exemplo rapido
+
+```python
+from datetime import datetime
+
+from mtchart_sdk import MTChartService, PartItem, PenConfig, ProcessInput
+
+service = MTChartService()
+
+process = service.create_process(
+    ProcessInput(
+        report_number="CH-0001",
+        project="OS-123",
+        process_name="Alivio de fragilizacao",
+        oven="Forno 01",
+        relief_hours=3,
+        pen=PenConfig(id="1", name="Pena 1", stabilization_target=189, low_limit=175.9),
+        items=[
+            PartItem(name="Suporte", pn="PN-001", sn="SN-001", qty=1),
+        ],
+        started_at=datetime(2026, 6, 28, 8, 0, 0),
+    )
+)
+
+reading = service.evaluate_reading(process, value=188.7)
+
+print(process.report_number)
+print(reading.status)
+print(reading.can_start_process)
+```
+
+## Estrutura
+
+- `mtchart_sdk.models`: modelos de dados do processo.
+- `mtchart_sdk.rules`: regras puras de temperatura e tempo.
+- `mtchart_sdk.storage`: catalogo SQLite local de pecas.
+- `mtchart_sdk.service`: fachada principal para uso por outros sistemas.
+- `mtchart_sdk.cli`: demonstracao de linha de comando para validar instalacao.
+- `examples/basic_process.py`: exemplo minimo executavel.
+
+## API principal
+
+- `MTChartService.create_process(data)`: normaliza pecas, calcula quantidade total e previsao de saida.
+- `MTChartService.evaluate_reading(process, value)`: classifica leitura como `OK`, `LOW`, `HIGH` ou `N/A`.
+- `MTChartService.search_parts(term)`: consulta o catalogo local de pecas por nome ou PN.
+- `clean_identifier(value)`: remove prefixos comuns como `PN:`, `P/N:`, `LOTE:` e `BATCH:`.
+
+## CLI de demonstracao
+
+Depois de instalar localmente, rode:
+
+```powershell
+mtchart-sdk-demo --value 188.7
+```
+
+Ou sem instalar como script:
+
+```powershell
+python -m mtchart_sdk.cli --catalog-db .tmp_demo.db --value 188.7
+```
+
+O comando cria um processo ficticio, avalia a leitura e retorna um JSON com
+status, previsao de saida e resultados do catalogo local.
+
+## Validacao local
+
+Para validar uma copia local do SDK durante desenvolvimento:
+
+```powershell
+python tools/validate_package.py
+```
+
+O validador confere metadados, compila os modulos, roda testes e executa o
+exemplo/CLI de demonstracao.
+
+## Status
+
+Versao inicial. A API esta pronta para instalacao, testes locais e evolucao incremental.

mtchart_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+mtchart_sdk/__init__.py,sha256=IJ8bMwv2YOQ6PmPSF3GH5ytZuf2ynCVcZf471KlJ7q4,677
+mtchart_sdk/cli.py,sha256=Jq9QbhOSy4ItCc4Cw_mpMv6-tdBlqoChs71KdvvdBuM,3759
+mtchart_sdk/models.py,sha256=f-BmGrFEfbOOHK3ueki1cjq4tvbyfv03D2yrX5gaJb4,1437
+mtchart_sdk/rules.py,sha256=JgsVtwJ6OIqcGiwNVhuj_CcKfunfForPXY65ar2Yiro,3265
+mtchart_sdk/service.py,sha256=GIB8Jan4UoVhl4hxXSU-HUVeXWwRk9DrPCoVlM-iRUE,1954
+mtchart_sdk/storage.py,sha256=4K9iwyp7gk2CieRSS0O6iFShBabxqgiHiVKSg2c2VF8,3614
+mtchart_sdk-0.1.0.dist-info/licenses/LICENSE.md,sha256=qiHPDS6FSlbg5G-Eoh7dFcOtXLOBvX9hXigb-El1LhE,667
+mtchart_sdk-0.1.0.dist-info/METADATA,sha256=R6SiwpPqQD5mJfLJX2OSMcRI1-gek4IukCq3ogb2SXM,4110
+mtchart_sdk-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+mtchart_sdk-0.1.0.dist-info/entry_points.txt,sha256=g2AdcwosARJ0uoEVK4gwINHguvPstiD-IcYEL0FGXC4,58
+mtchart_sdk-0.1.0.dist-info/top_level.txt,sha256=msH_FVGlPkDhfnxYswk6bdyN936yoMv7sjS6vSpnLm0,12
+mtchart_sdk-0.1.0.dist-info/RECORD,,

mtchart_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mtchart_sdk-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mtchart-sdk-demo = mtchart_sdk.cli:main

mtchart_sdk-0.1.0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,15 @@
+Proprietary Commercial License
+
+Copyright (c) 2026 MTD Softwares.
+
+This SDK is provided as a commercial/proprietary component derived from
+MTChart Pro. Use, redistribution, sublicensing, resale, or incorporation into
+third-party products requires written authorization from MTD Softwares.
+
+Developers may use this local copy only for evaluation, internal testing, and
+integration planning unless a separate commercial license grants broader
+rights.
+
+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.

mtchart_sdk-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mtchart_sdk