@aryacode/dsh-engineering 0.0.0-stage → 0.4.0

package/vendor/mwi/code/engine/motionworks_iec_mcp/structure.py

@@ -0,0 +1,98 @@
+"""Independent saved structural/source evidence for native IDE mutations."""
+import hashlib
+import re
+import xml.etree.ElementTree as ET
+from .project import Project
+from .cfb import CompoundFile
+from .tree import parse_document, task_assignments
+from .tasks import read_tasks
+from .program_checks import mask
+from .workflow import source_manifest
+
+# Exact native empty GB emitted by MotionWorks IEC 3 Pro / Ade 1.19.
+# Independently observed in two LD and two FBD creations. Unknown versions,
+# truncated bodies and populated bodies must not be inferred to be empty.
+EMPTY_GRAPH_SHA256 = '09985918e42e9108dd10f5d67cbafa125bd4938821c6c6efe160e735b49492bb'
+
+def body_is_blank(language, raw, text=None):
+    if language in ('ST', 'IL'):
+        return text is not None and not text.strip()
+    return language in ('LD', 'FBD') and len(raw) == 292 and hashlib.sha256(raw).hexdigest() == EMPTY_GRAPH_SHA256
+
+def snapshot(root):
+    project=Project(root)
+    document=parse_document(CompoundFile(root/'src.st1').read_stream('PROJECT.TRE').decode('latin1'))
+    if document.warnings:raise ValueError('Project tree parse warnings')
+    registry={}
+    for line in project.list_pou_lines():
+        columns=line.split('\t')
+        kind=columns[0].upper().replace('FUNCTIONBLOCK','FUNCTION_BLOCK')
+        if kind not in ('PROGRAM','FUNCTION','FUNCTION_BLOCK') or len(columns)<3:raise ValueError('Unsupported POU registry row')
+        if columns[1].casefold() in registry:raise ValueError('Duplicate POU registry row')
+        registry[columns[1].casefold()]=(kind,columns[2])
+    pous=[]
+    for pou in project.pous():
+        if pou.name.casefold() not in registry:raise ValueError('Unregistered POU directory')
+        table=pou.declarations()
+        if table.warnings:raise ValueError('Declaration parse warnings')
+        body_stream=pou.body_stream()
+        if not body_stream:raise ValueError('Missing POU body')
+        body=(pou.st_body() if body_stream[1]=='ST' else pou.text_body()) if body_stream[1] in ('ST','IL') else None
+        raw=body.encode('utf-8') if body is not None else pou.source().read_stream(body_stream[0])
+        variables=[dict(name=v.name,type=v.type_name,section=v.section,group=v.group,
+                        address=v.address,initial_value=v.initial_value,description=v.description) for v in table.variables]
+        kind,_=registry[pou.name.casefold()]
+        parents=[node for node,_ in document.walk_with_ancestors()
+                 if node.name.casefold()==pou.name.casefold() and
+                 node.path.split('\t')[0].replace('\\','/').casefold()=='poe/'+pou.name.casefold()]
+        if len(parents)!=1:raise ValueError('POU registry/tree identity mismatch')
+        return_type=document.lines[parents[0].line+3].strip() if kind=='FUNCTION' else ''
+        if kind=='FUNCTION' and not return_type:raise ValueError('Missing function return type in saved tree')
+        pous.append(dict(name=pou.name,type=kind,return_type=return_type,language=body_stream[1],
+                         body_sha256=hashlib.sha256(raw).hexdigest(),body_blank=body_is_blank(body_stream[1],raw,body),
+                         variables=variables,identifiers=sorted(set(re.findall(r'[A-Za-z_][A-Za-z_0-9]*',mask(body or '').upper()))),
+                         reference_scan_complete=body is not None))
+    if len(pous)!=len(registry):raise ValueError('Missing registered POU source')
+    task_nodes=[]
+    for node,_ in document.walk_with_ancestors():
+        path=node.path.split('\t')[0].replace('\\','/').split('/')
+        if len(path)==5 and path[0]=='C' and path[2]=='R' and path[-1]==node.name:
+            fields=node.path.split('\t')
+            instances=[]
+            for child in node.children:
+                program_type=document.lines[child.line+2].split('\t')[0]
+                if not program_type:raise ValueError('Missing saved program type')
+                instances.append(dict(name=child.name,type=program_type))
+            task_nodes.append(dict(name=node.name,kind=fields[3],instances=instances))
+    settings={t.name.casefold():t for t in read_tasks(root)}
+    if len(settings)!=len(task_nodes):raise ValueError('Task settings/tree inventory mismatch')
+    for task in task_nodes:
+        setting=settings[task['name'].casefold()]
+        if setting.warnings or setting.type!=task['kind']:raise ValueError('Task settings/tree disagree')
+        task['settings']=setting.fields
+    globals=project.global_variables()
+    if globals.warnings:raise ValueError('Global declaration parse warnings')
+    global_rows=[dict(name=v.name,type=v.type_name,section=v.section,group=v.group,
+                      address=v.address,initial_value=v.initial_value,description=v.description) for v in globals.variables]
+    manifest=source_manifest(root)
+    program_sources={file:{name:sha for name,sha in streams.items() if name.upper().endswith(('.VB','.VGR','.STB','.AB','.GB','.TXT'))}
+                     for file,streams in manifest['streams'].items()}
+    file_hashes=dict(manifest['files'])
+    for setting in settings.values():
+        file_hashes[setting.source.relative_to(root).as_posix()]=hashlib.sha256(setting.source.read_bytes()).hexdigest()
+    translations={}
+    empty_translations=[]
+    for pou in project.pous():
+        for path in pou.directory.iterdir():
+            if path.name.casefold().endswith('translation.xml'):
+                key=path.relative_to(root).as_posix()
+                translations[key]=hashlib.sha256(path.read_bytes()).hexdigest()
+                file_hashes[key]=translations[key]
+                try:
+                    translation_document=ET.parse(path)
+                    if translation_document.getroot().tag=='TranslationDocument' and not translation_document.findall('./ItemList/item'):
+                        empty_translations.append(key)
+                except ET.ParseError:
+                    pass  # Older unused translation placeholders may be all zero bytes.
+    return dict(pous=pous,tasks=task_nodes,globals=global_rows,program_sources=program_sources,
+                translation_files=translations,empty_translation_files=empty_translations,file_hashes=file_hashes)

package/vendor/mwi/code/engine/motionworks_iec_mcp/task_bindings.py

@@ -0,0 +1,68 @@
+"""Exact saved PROGRAM instance ownership, separate from runtime execution."""
+import hashlib
+import re
+from pathlib import Path
+from .cfb import CompoundFile
+from .tree import parse_document
+from .tasks import parse_task_settings
+
+IDENT = re.compile(r'^[A-Za-z_][A-Za-z_0-9]*$')
+
+def resolve(document, programs):
+    if document.warnings:
+        raise ValueError('Task tree parse warnings')
+    known = {name.casefold(): name for name in programs}
+    if len(known) != len(programs): raise ValueError('Duplicate PROGRAM registry identity')
+    tasks, identities = [], set()
+    for node, _ in document.walk_with_ancestors():
+        fields = node.path.split('\t')
+        path = fields[0].replace('\\', '/').split('/')
+        if len(path) != 5 or path[0] != 'C' or path[2] != 'R' or path[-1] != node.name:
+            continue
+        if len(fields) < 4 or fields[3] not in ('CYCLIC','DEFAULT','SYSTEM') or not all(IDENT.fullmatch(p) for p in (path[1],path[3],node.name)):
+            raise ValueError('Unsupported task identity/kind')
+        identity = '/'.join(path)
+        if identity.casefold() in identities: raise ValueError('Duplicate task identity')
+        identities.add(identity.casefold()); instances, names = [], set()
+        for order, child in enumerate(node.children):
+            if child.children or not IDENT.fullmatch(child.name) or child.name.casefold() in names:
+                raise ValueError('Ambiguous PROGRAM instance identity')
+            names.add(child.name.casefold())
+            program = document.lines[child.line+2].split('\t')[0]
+            if program.casefold() not in known:
+                raise ValueError('Task instance type is absent from PROGRAM registry: '+program)
+            instances.append(dict(name=child.name,type=known[program.casefold()],order=order+1))
+        tasks.append(dict(name=node.name,configuration=path[1],resource=path[3],
+                          path=identity,kind=fields[3],instances=instances))
+    return tasks
+
+def inspect(root):
+    root = Path(root)
+    registry = root/'LIST.POU'; tree = root/'src.st1'
+    before = {str(p):hashlib.sha256(p.read_bytes()).hexdigest() for p in (registry,tree)}
+    programs, seen = [], set()
+    for line in registry.read_text(encoding='latin1').splitlines():
+        if not line.strip(): continue
+        columns = line.split('\t')
+        if len(columns)<2 or columns[0].upper().replace('FUNCTIONBLOCK','FUNCTION_BLOCK') not in ('PROGRAM','FUNCTION','FUNCTION_BLOCK') or not IDENT.fullmatch(columns[1]) or columns[1].casefold() in seen:
+            raise ValueError('Invalid/duplicate POU registry identity')
+        seen.add(columns[1].casefold())
+        if columns[0].upper() == 'PROGRAM': programs.append(columns[1])
+    document = parse_document(CompoundFile(tree).read_stream('PROJECT.TRE').decode('latin1'))
+    tasks = resolve(document,programs)
+    for task in tasks:
+        source = root/Path(task['path']).parent/(task['name']+'.SET')
+        if not source.resolve().is_relative_to(root.resolve()): raise ValueError('Task settings escape project')
+        raw = source.read_bytes(); before[str(source)] = hashlib.sha256(raw).hexdigest()
+        settings = parse_task_settings(raw.decode('latin1'),source)
+        if settings.warnings or settings.name.casefold()!=task['name'].casefold() or settings.type!=task['kind']:
+            raise ValueError('Task settings/tree identity or kind mismatch')
+        task['settings'] = settings.fields
+        task['settings_source'] = str(source)
+    for path, digest in before.items():
+        if hashlib.sha256(Path(path).read_bytes()).hexdigest()!=digest:
+            raise ValueError('Task sources changed during read')
+    assigned = {instance['type'].casefold() for task in tasks for instance in task['instances']}
+    return dict(bindings=tasks,program_types=programs,
+                unassigned=sorted(name for name in programs if name.casefold() not in assigned),
+                binding_resolution='exact_saved_tree',source_hashes=before)

package/vendor/mwi/code/engine/motionworks_iec_mcp/tasks.py

@@ -0,0 +1,162 @@
+"""Read MotionWorks task configuration.
+
+Each resource task has a plain-text ``<Task>.SET`` file beside the resource
+``src.st1``::
+
+    TASK FastTsk
+    (TYPE := CYCLIC,
+    INTERVAL := T#4ms,
+    PRIORITY := 0,
+    WATCHDOG := 4
+    WATCHDOG_DISPLAY := 4
+    WATCHDOG_ENABLED := YES
+    );
+
+This is useful context for anyone editing motion code.  Cycle time and priority
+decide whether a block can finish in its task, and the watchdog decides what
+happens when it cannot -- both matter more in motion control than in ordinary PLC
+logic, and neither is visible from the POU bodies alone.
+
+The format is close to IEC structured text but is not valid ST: fields are
+newline-separated inside the parentheses and only the last one carries a
+semicolon, so a real ST parser rejects it.  This reader is therefore its own
+small field parser rather than a reuse of the declaration parser.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .errors import NotFound
+
+#: ``TASK <name>`` on the first meaningful line.
+_TASK_RE = re.compile(r"^\s*TASK\s+(\S+)", re.IGNORECASE)
+#: ``FIELD := value`` with an optional trailing comma or semicolon.
+_FIELD_RE = re.compile(r"([A-Za-z_][A-Za-z0-9_]*)[ \t]*:=[ \t]*([^,;\r\n]*)")
+
+
+@dataclass
+class TaskSettings:
+    """One task's configuration."""
+
+    name: str
+    source: Path
+    fields: dict[str, str] = field(default_factory=dict)
+    warnings: list[str] = field(default_factory=list)
+
+    @property
+    def type(self) -> str | None:
+        return self.fields.get("TYPE")
+
+    @property
+    def interval(self) -> str | None:
+        """Cycle time such as ``T#4ms``, for cyclic tasks."""
+        return self.fields.get("INTERVAL")
+
+    @property
+    def priority(self) -> int | None:
+        raw = self.fields.get("PRIORITY")
+        try:
+            return int(raw) if raw is not None else None
+        except ValueError:
+            return None
+
+    @property
+    def watchdog(self) -> str | None:
+        return self.fields.get("WATCHDOG")
+
+    @property
+    def watchdog_enabled(self) -> bool | None:
+        raw = self.fields.get("WATCHDOG_ENABLED")
+        if raw is None:
+            return None
+        return raw.strip().upper() in {"YES", "TRUE", "1"}
+
+    def summary(self) -> str:
+        bits = [f"TYPE={self.type or '?'}"]
+        if self.interval:
+            bits.append(f"cycle={self.interval}")
+        if self.priority is not None:
+            bits.append(f"priority={self.priority}")
+        # Report the watchdog whenever we know anything about it.  Gating this on
+        # a WATCHDOG value alone hid the "disabled" state for tasks that set only
+        # WATCHDOG_ENABLED, which is exactly the case worth surfacing.
+        if self.watchdog or self.watchdog_enabled is not None:
+            state = " (disabled)" if self.watchdog_enabled is False else ""
+            bits.append(f"watchdog={self.watchdog or 'n/a'}{state}")
+        for key in ("SPG", "INTERVAL_DISPLAY"):
+            if key in self.fields:
+                bits.append(f"{key.lower()}={self.fields[key]}")
+        return "  ".join(bits)
+
+
+def parse_task_settings(text: str, source: Path | None = None) -> TaskSettings:
+    """Parse a ``.SET`` payload.
+
+    Raises :class:`NotFound` when the text does not begin with a ``TASK`` line,
+    which is how a non-task ``.SET`` file is rejected rather than mis-parsed.
+    """
+    match = _TASK_RE.search(text)
+    if match is None:
+        raise NotFound(
+            f"{source.name if source else '<text>'} is not a task settings file "
+            f"(no TASK line)"
+        )
+
+    settings = TaskSettings(
+        name=match.group(1).strip(),
+        source=source or Path("<text>"),
+    )
+    for field_match in _FIELD_RE.finditer(text):
+        key = field_match.group(1).upper()
+        value = field_match.group(2).strip()
+        if key in settings.fields:
+            settings.warnings.append(f"duplicate field {key!r}; kept the first")
+            continue
+        settings.fields[key] = value
+    return settings
+
+
+def task_files(project_root: Path) -> list[Path]:
+    """Every ``*.SET`` that looks like a task configuration in a project."""
+    root = Path(project_root)
+    found: list[Path] = []
+    for pattern in ("C/Configuration/R/Resource", "C/Resource/R/Resource"):
+        directory = root / pattern
+        if directory.is_dir():
+            found.extend(sorted(directory.glob("*.SET")))
+    return found
+
+
+def read_tasks(project_root: Path) -> list[TaskSettings]:
+    """Read every task configuration in a project.
+
+    Task files sit beside the resource ``src.st1``.  Files that are not task
+    settings are skipped rather than treated as errors, because the same
+    directory holds other ``.SET`` files.
+    """
+    settings: list[TaskSettings] = []
+    for path in task_files(project_root):
+        try:
+            text = path.read_bytes().decode("latin1")
+        except OSError:
+            continue
+        try:
+            settings.append(parse_task_settings(text, path))
+        except NotFound:
+            continue
+    # Present cyclic tasks in ascending cycle time, which is how a user thinks
+    # about them: the fastest task is the one with the least time to spare.
+    def sort_key(item: TaskSettings):
+        interval = item.interval or ""
+        match = re.search(r"T#(\d+(?:\.\d+)?)(ms|us|s|ns)?", interval, re.IGNORECASE)
+        if not match:
+            return (2, 0.0, item.name)
+        value = float(match.group(1))
+        unit = (match.group(2) or "ms").lower()
+        scale = {"ns": 1e-6, "us": 1e-3, "ms": 1.0, "s": 1000.0}[unit]
+        return (0, value * scale, item.name)
+
+    return sorted(settings, key=sort_key)

package/vendor/mwi/code/engine/motionworks_iec_mcp/transaction.py

@@ -0,0 +1,157 @@
+"""Recoverable offline transactions. A successful file write is not a build verdict."""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+from uuid import uuid4
+
+from .errors import MotionWorksError
+from .ide import ensure_ide_closed
+from .snapshot import sha256_file
+from .staging import assert_proven, workspace_root
+
+
+def hash_tree(root):
+    """A rollback snapshot includes generated files and hidden directories too."""
+    return {p.relative_to(root).as_posix(): sha256_file(p)
+            for p in sorted(Path(root).rglob('*')) if p.is_file()}
+
+
+def _save(path: Path, payload: dict) -> None:
+    temp = path.with_suffix('.tmp')
+    temp.write_text(json.dumps(payload, indent=2), encoding='utf-8')
+    os.replace(temp, path)
+
+
+def _restore(root: Path, backup: Path, before: dict[str, str]) -> None:
+    # Verify the complete rollback set before replacing even one source file.
+    for name, digest in before.items():
+        if sha256_file(backup / name) != digest:
+            raise MotionWorksError(f'Rollback backup failed verification: {name}')
+    for path in sorted(root.rglob('*'), reverse=True):
+        if path.is_file() and path.relative_to(root).as_posix() not in before:
+            path.unlink()
+    for name in before:
+        target = root / name
+        target.parent.mkdir(parents=True, exist_ok=True)
+        temp = target.with_name(target.name + '.rollback-' + uuid4().hex)
+        shutil.copy2(backup / name, temp)
+        os.replace(temp, target)
+    for path in sorted(root.rglob('*'), reverse=True):
+        if path.is_dir() and not any(path.iterdir()):
+            path.rmdir()
+    if hash_tree(root) != before:
+        raise MotionWorksError('Rollback read-back differs from the recorded snapshot')
+
+
+def update_metadata(root: Path) -> None:
+    path = root / 'PROJECT.INF'
+    if not path.exists():
+        return
+    raw = path.read_bytes()
+    if raw.startswith((b'\xff\xfe', b'\xfe\xff')):
+        encoding = 'utf-16'
+    else:
+        encoding = 'latin1'
+    text = raw.decode(encoding)
+    updated, count = re.subn(r'(?m)^LastChange=[^\r\n]*',
+        'LastChange=' + datetime.now().strftime('%m/%d/%Y  %I:%M:%S %p'), text)
+    if count != 1:
+        raise MotionWorksError('PROJECT.INF must have exactly one LastChange field')
+    temp = path.with_name(path.name + '.transaction-' + uuid4().hex)
+    temp.write_bytes(updated.encode(encoding))
+    os.replace(temp, path)
+
+
+def run(project: Path, operation, *, validate=None) -> dict:
+    """Commit a whole operation or restore its complete pre-operation file set.
+
+    The lock remains after a process crash or failed rollback. A later writer refuses;
+    it never silently treats an incomplete transaction as committed.
+    """
+    root = assert_proven(project)
+    if root.suffix.lower() == '.mwt':
+        root = root.with_suffix('')
+    if not root.is_dir():
+        raise MotionWorksError('Transaction requires an expanded project directory')
+    ensure_ide_closed(auto_close=False)
+    home = workspace_root() / '.motionworks'
+    key = hashlib.sha256(str(root).casefold().encode()).hexdigest()[:20]
+    lock = home / 'locks' / (key + '.lock')
+    if not lock.resolve().is_relative_to(workspace_root()):
+        raise MotionWorksError('Transaction lock escapes the workspace')
+    lock.parent.mkdir(parents=True, exist_ok=True)
+    transaction_id = datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%S.%fZ-') + uuid4().hex[:8]
+    folder = home / 'transactions' / key / transaction_id
+    if not folder.resolve().is_relative_to(workspace_root()):
+        raise MotionWorksError('Transaction journal escapes the workspace')
+    try:
+        fd = os.open(lock, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+    except FileExistsError as exc:
+        raise MotionWorksError(f'Project transaction is locked; inspect {lock} before recovery') from exc
+    with os.fdopen(fd, 'w') as handle:
+        json.dump({'pid': os.getpid(), 'journal': str(folder / 'journal.json')}, handle)
+    clean = False
+    before = None
+    journal = {'id': transaction_id, 'project': str(root), 'state': 'preparing',
+               'verification': 'offline_only', 'required': ['rebuild', 'make', 'save', 'close_reopen']}
+    try:
+        folder.mkdir(parents=True)
+        before = hash_tree(root)
+        shutil.copytree(root, folder / 'before')
+        if hash_tree(folder / 'before') != before or hash_tree(root) != before:
+            raise MotionWorksError('Source changed during snapshot or backup did not verify')
+        journal.update(state='prepared', before=before)
+        _save(folder / 'journal.json', journal)
+        # Recheck after potentially slow backup, immediately before changing files.
+        ensure_ide_closed(auto_close=False)
+        journal['state'] = 'applying'
+        _save(folder / 'journal.json', journal)
+        payload = operation()
+        if payload.get('ok') is False:
+            raise MotionWorksError('Operation reported failure: ' + json.dumps(payload))
+        if validate:
+            validation = validate(root)
+        else:
+            from .validation import validate as validate_native
+            current = hash_tree(root)
+            changed_containers = [root / name for name, digest in current.items()
+                                  if Path(name).name.lower() == 'src.st1' and before.get(name) != digest]
+            validation = validate_native(root, containers=changed_containers) if changed_containers else {'status': 'operation_readback_only'}
+        if validation.get('ok') is False:
+            raise MotionWorksError('Static validation failed: ' + json.dumps(validation))
+        after = hash_tree(root)
+        if after != before:
+            update_metadata(root)
+            after = hash_tree(root)
+        changed = sorted(name for name in set(before) | set(after) if before.get(name) != after.get(name))
+        journal.update(state='committed', after=after, changed_files=changed, validation=validation)
+        _save(folder / 'journal.json', journal)
+        report = {k: journal[k] for k in ('id', 'state', 'verification', 'required', 'changed_files', 'validation')}
+        report.update(journal=str(folder / 'journal.json'), backup=str(folder / 'before'),
+                      hashes={name: {'before': before.get(name), 'after': after.get(name)} for name in changed})
+        payload.setdefault('result', {})['transaction'] = report
+        clean = True
+        return payload
+    except Exception as exc:
+        if journal['state'] in ('applying', 'committed'):
+            try:
+                ensure_ide_closed(auto_close=False)
+                assert_proven(root)
+                _restore(root, folder / 'before', before)
+                journal.update(state='rolled_back', error=str(exc))
+                _save(folder / 'journal.json', journal)
+                clean = True
+            except Exception as rollback_error:
+                raise MotionWorksError(f'Operation failed: {exc}; rollback needs recovery: {rollback_error}; journal: {folder}') from exc
+        else:
+            clean = True  # No project mutation has begun.
+        raise MotionWorksError(f'Offline transaction failed: {exc}; journal: {folder}') from exc
+    finally:
+        if clean:
+            lock.unlink(missing_ok=True)