cpp-xer-parser 0.6.1__py3-none-any.whl

cpp_xer_parser/__init__.py

@@ -0,0 +1,38 @@
+"""cpp-xer-parser, installed: ``pip install cpp-xer-parser``.
+
+The package is the repository's scripts/ directory. Everything the parser
+offers is in ``cpp_xer_parser.xer_parser``; the names below are the ones
+most callers need::
+
+    from cpp_xer_parser import parse_xer, get_table, print_summary
+
+A plain clone does not import this file: it puts scripts/ on sys.path and
+imports ``xer_parser`` directly, as the README's quick start shows.
+"""
+from .xer_parser import (  # noqa: F401
+    build_activity_code_map,
+    build_predecessor_map,
+    build_resource_map,
+    build_udf_map,
+    build_wbs_map,
+    compute_half_step_xer,
+    generate_summary,
+    generate_xer,
+    get_calendar_map,
+    get_fields,
+    get_table,
+    get_work_days_between,
+    parse_xer,
+    print_summary,
+    validate_schedule,
+)
+
+__version__ = '0.6.1'
+
+__all__ = [
+    'parse_xer', 'get_table', 'get_fields', 'get_calendar_map',
+    'get_work_days_between', 'build_wbs_map', 'build_resource_map',
+    'build_predecessor_map', 'build_activity_code_map', 'build_udf_map',
+    'generate_summary', 'print_summary', 'generate_xer',
+    'compute_half_step_xer', 'validate_schedule', '__version__',
+]

cpp_xer_parser/config_profiles.py

@@ -0,0 +1,131 @@
+"""
+config_profiles.py — minimal DCMA-14 / cp_validator threshold profiles
+
+Public, standalone subset of the profile registry used by cp_validator and
+dcma14. The full version lives inside the Critical Path Partners internal
+`_cpp_common` module and additionally drives forensic-delay-analysis,
+schedule-risk-analysis, and time-impact-analysis. This subset covers the
+threshold keys consumed by the DCMA-14 check suite.
+
+Three profiles ship out of the box:
+  - `commercial` — generic commercial-construction defaults
+  - `nuclear`    — tightened thresholds suitable for nuclear / heavy energy
+                    where regulator scrutiny is high
+  - `mining`     — slightly relaxed thresholds for resource-driven mining
+                    schedules where some DCMA assumptions don't translate
+
+Callers pass a profile by name (e.g. the `profile` parameter on
+`dcma_14_assess`). `get_profile` looks the name up in `_PROFILES`, so an
+unknown name raises ValueError and a dict raises TypeError. It returns a copy,
+which callers may read or change without affecting the registry. To run other
+thresholds, add an entry to `_PROFILES` with every key the bundled profiles
+carry, and pass its name.
+
+The keys of the commercial profile below are commented with the DCMA 14-Point
+criterion each one sets, in the published numbering; the `_check_NN_*`
+functions in dcma14.py read them by name.
+"""
+
+from typing import Dict
+
+
+# ─────────────────────────────────────────────────────────────────────
+# Profile registry
+# ─────────────────────────────────────────────────────────────────────
+
+_COMMERCIAL: Dict[str, object] = {
+    'name': 'Commercial Construction',
+    # DCMA 14-Point thresholds
+    'dcma_logic_max_missing_pct':       5.0,   # #1  Logic
+    'dcma_leads_max_count':             0,     # #2  Leads (negative lags)
+    'dcma_lags_max_pct':                5.0,   # #3  Lags
+    'dcma_fs_min_pct':                  90.0,  # #4  FS Relationship %
+    'dcma_hard_constraints_max_pct':    5.0,   # #5  Hard Constraints
+    'dcma_high_float_max_days':         44,    # #6  High Float threshold
+    'dcma_high_float_max_pct':          5.0,
+    'dcma_negative_float_max_count':    0,     # #7  Negative Float
+    'dcma_high_duration_max_days':      44,    # #8  High Duration threshold
+    'dcma_high_duration_max_pct':       5.0,
+    'dcma_invalid_dates_max_count':     0,     # #9  Invalid Dates / Future Actuals
+    'dcma_resources_min_pct':           100.0, # #10 Resources: every activity of 1+ working day resourced, on every profile (the written DCMA definition)
+    'dcma_missed_tasks_max_pct':        5.0,   # #11 Missed Tasks
+    'dcma_cpli_min':                    0.95,  # #13 CPLI
+    'bei_min':                          0.95,  # #14 BEI
+}
+
+_NUCLEAR: Dict[str, object] = {
+    'name': 'Nuclear / Heavy Energy',
+    'dcma_logic_max_missing_pct':       1.0,
+    'dcma_leads_max_count':             0,
+    'dcma_lags_max_pct':                2.0,
+    'dcma_fs_min_pct':                  95.0,
+    'dcma_hard_constraints_max_pct':    2.0,
+    'dcma_high_float_max_days':         30,
+    'dcma_high_float_max_pct':          3.0,
+    'dcma_negative_float_max_count':    0,
+    'dcma_high_duration_max_days':      20,
+    'dcma_high_duration_max_pct':       3.0,
+    'dcma_invalid_dates_max_count':     0,
+    'dcma_resources_min_pct':           100.0,
+    'dcma_missed_tasks_max_pct':        3.0,
+    'dcma_cpli_min':                    0.98,
+    'bei_min':                          0.98,
+}
+
+_MINING: Dict[str, object] = {
+    'name': 'Mining / Resource-Driven',
+    'dcma_logic_max_missing_pct':       5.0,
+    'dcma_leads_max_count':             0,
+    'dcma_lags_max_pct':                10.0,
+    'dcma_fs_min_pct':                  85.0,
+    'dcma_hard_constraints_max_pct':    8.0,
+    'dcma_high_float_max_days':         90,
+    'dcma_high_float_max_pct':          10.0,
+    'dcma_negative_float_max_count':    0,
+    'dcma_high_duration_max_days':      90,
+    'dcma_high_duration_max_pct':       10.0,
+    'dcma_invalid_dates_max_count':     0,
+    'dcma_resources_min_pct':           100.0,
+    'dcma_missed_tasks_max_pct':        5.0,
+    'dcma_cpli_min':                    0.93,
+    'bei_min':                          0.92,
+}
+
+_PROFILES: Dict[str, Dict[str, object]] = {
+    'commercial': _COMMERCIAL,
+    'nuclear':    _NUCLEAR,
+    'mining':     _MINING,
+}
+
+
+def get_profile(name: str) -> Dict[str, object]:
+    """Return the threshold dict for a named profile.
+
+    Parameters
+    ----------
+    name : 'commercial' | 'nuclear' | 'mining'
+
+    Returns
+    -------
+    dict
+        A shallow copy of the registered profile. Callers may mutate the
+        return value without affecting the registry.
+
+    Raises
+    ------
+    ValueError
+        If `name` is not a registered profile.
+    """
+    if name not in _PROFILES:
+        valid = sorted(_PROFILES)
+        raise ValueError(f"Unknown profile {name!r}; valid: {valid}")
+    # Return a copy so callers can safely mutate.
+    return dict(_PROFILES[name])
+
+
+def list_profiles() -> Dict[str, str]:
+    """Return {profile_id: human_name} over all registered profiles."""
+    return {pid: prof.get('name', pid) for pid, prof in _PROFILES.items()}
+
+
+__all__ = ['get_profile', 'list_profiles']

cpp_xer_parser/validation.py

@@ -0,0 +1,164 @@
+"""
+validation.py — minimal Finding / ValidationReport types
+
+Public, standalone subset of the validation primitives used by cp_validator
+and dcma14. The full version lives inside the Critical Path Partners
+internal `_cpp_common` module and carries additional plumbing for the
+forensic-suite-wide audit trail. This subset is sufficient for the OSS
+critical-path-validator, and for `xer_parser.validate_schedule` and
+`xer_parser.aace_31r_compliance`, to run end-to-end from a plain clone.
+
+The four severity sentinels (BLOCK / WARN / INFO / PASS) are plain strings —
+matching the public-API contract of the full version — so any code that
+imports them, compares against them, or includes them in serialized output
+will behave identically.
+
+`ValidationReport.to_dict()` carries the full version's `summary` block: the
+number of findings at each severity, the total, and `worst_severity`, the
+worst severity present (BLOCK > WARN > INFO > PASS; PASS for an empty
+report). A caller that reads `to_dict()['summary']['worst_severity']` gets
+the same answer from either version. Two differences remain, both kept so
+that output this subset already produced does not move: `to_dict()` also
+carries this subset's `counts` key, and it lists findings in the order they
+were added, where the full version sorts them worst first.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+# ─────────────────────────────────────────────────────────────────────
+# Severity sentinels
+# Public-API contract: these are strings. Compare with ==, not `is`.
+# ─────────────────────────────────────────────────────────────────────
+BLOCK = 'BLOCK'   # Forensic-correctness blocker. Findings at this level fail the suite.
+WARN  = 'WARN'    # Caution-level finding. The schedule may still be usable.
+INFO  = 'INFO'    # Informational note. No corrective action implied.
+PASS  = 'PASS'    # Check passed. No finding to report.
+
+_VALID_SEVERITIES = (BLOCK, WARN, INFO, PASS)
+
+# Rank of each severity, worst highest. `ValidationReport.worst_severity`
+# reads the worst finding by this order.
+_SEVERITY_ORDER = {BLOCK: 3, WARN: 2, INFO: 1, PASS: 0}
+
+
+@dataclass
+class Finding:
+    """A single validation finding produced by a check.
+
+    Attributes
+    ----------
+    severity   : one of BLOCK / WARN / INFO / PASS
+    check_id   : stable identifier for the check (e.g. 'DCMA-01-Logic')
+    message    : human-readable description
+    reference  : citation string (e.g. 'DCMA 14-Point #1', 'AACE 49R-06')
+    evidence   : structured supporting data (key/value, e.g. {'value': ..., 'threshold': ...})
+    """
+    severity: str
+    check_id: str
+    message: str
+    reference: str = ''
+    evidence: Dict[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self):
+        if self.severity not in _VALID_SEVERITIES:
+            raise ValueError(
+                f"Finding.severity must be one of {_VALID_SEVERITIES}; got {self.severity!r}"
+            )
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            'severity': self.severity,
+            'check_id': self.check_id,
+            'message': self.message,
+            'reference': self.reference,
+            'evidence': dict(self.evidence),
+        }
+
+
+@dataclass
+class ValidationReport:
+    """An ordered list of Finding instances plus a subject and context.
+
+    Attributes
+    ----------
+    subject : free-form report title (e.g. 'DCMA 14-Point Assessment [commercial]')
+    context : free-form metadata (profile name, schedule identifiers, etc.)
+    findings: ordered list of Finding instances (insertion order preserved)
+    """
+    subject: str = ''
+    context: Dict[str, Any] = field(default_factory=dict)
+    findings: List[Finding] = field(default_factory=list)
+
+    def add(self, finding: Finding) -> None:
+        """Append a Finding to the report."""
+        if not isinstance(finding, Finding):
+            raise TypeError(f"add() expects a Finding instance; got {type(finding).__name__}")
+        self.findings.append(finding)
+
+    def by_severity(self, severity: str) -> List[Finding]:
+        """Return findings filtered to one severity level."""
+        return [f for f in self.findings if f.severity == severity]
+
+    def count(self, severity=None):
+        """Return the number of findings at one severity level, or the
+        number of all findings when no severity is given.
+
+        Carried alongside `counts()` because callers use both shapes:
+        `xer_parser.aace_31r_compliance` scores a schedule by calling
+        `count(BLOCK)` and `count(WARN)` directly, so a subset without this
+        method makes that function raise AttributeError on a plain clone.
+        `count()` with no argument is the `total` in `to_dict()['summary']`,
+        as in the full version.
+        """
+        if severity is None:
+            return len(self.findings)
+        return sum(1 for f in self.findings if f.severity == severity)
+
+    @property
+    def worst_severity(self):
+        """Highest severity present, or PASS if none."""
+        if not self.findings:
+            return PASS
+        return max(self.findings, key=lambda f: _SEVERITY_ORDER[f.severity]).severity
+
+    def counts(self) -> Dict[str, int]:
+        """Return a dict of severity → count over all findings."""
+        out = {sev: 0 for sev in _VALID_SEVERITIES}
+        for f in self.findings:
+            out[f.severity] = out.get(f.severity, 0) + 1
+        return out
+
+    def has_blocking(self) -> bool:
+        """True if any finding is BLOCK severity."""
+        return any(f.severity == BLOCK for f in self.findings)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the report as a JSON-safe dict.
+
+        `summary` has the full version's keys and values: the count at each
+        severity, `total`, and `worst_severity`. `findings` are in the order
+        they were added (the full version sorts them worst first), and
+        `counts` is kept for callers of earlier releases.
+        """
+        return {
+            'subject': self.subject,
+            'context': dict(self.context),
+            'summary': {
+                'block': self.count(BLOCK),
+                'warn': self.count(WARN),
+                'info': self.count(INFO),
+                'pass': self.count(PASS),
+                'total': self.count(),
+                'worst_severity': self.worst_severity,
+            },
+            'findings': [f.to_dict() for f in self.findings],
+            'counts': self.counts(),
+        }
+
+
+__all__ = [
+    'BLOCK', 'WARN', 'INFO', 'PASS',
+    'Finding', 'ValidationReport',
+]