multidimensional-evaluation-engine 0.1.0__py3-none-any.whl

multidimensional_evaluation_engine/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

multidimensional_evaluation_engine/domain/__init__.py

@@ -0,0 +1 @@
+"""Domain models."""

multidimensional_evaluation_engine/domain/candidates.py

@@ -0,0 +1,30 @@
+"""domain/candidates.py: Domain models for evaluation inputs."""
+
+from dataclasses import dataclass, field
+
+
+def _default_metadata() -> dict[str, str]:
+    """Return default empty metadata mapping."""
+    return {}
+
+
+@dataclass(frozen=True)
+class Candidate:
+    """A generic candidate for multidimensional evaluation.
+
+    A candidate represents an entity being evaluated under a policy.
+    All domain-specific attributes are expressed as dimension values.
+
+    Attributes:
+        candidate_id: Stable identifier for the candidate.
+        candidate_name: Human-readable name.
+        dimensions: Mapping of dimension name to categorical value.
+        notes: Optional free-text annotation.
+        metadata: Optional auxiliary key-value data not used in scoring.
+    """
+
+    candidate_id: str
+    candidate_name: str
+    dimensions: dict[str, str]
+    notes: str = ""
+    metadata: dict[str, str] = field(default_factory=_default_metadata)

multidimensional_evaluation_engine/domain/results.py

@@ -0,0 +1,37 @@
+"""domain/results.py: Result models for candidate evaluation."""
+
+from dataclasses import dataclass, field
+
+from .candidates import Candidate
+
+
+def _default_levels() -> dict[str, str]:
+    """Return default empty levels mapping."""
+    return {}
+
+
+def _default_visual_levels() -> dict[str, str]:
+    """Return default empty visual levels mapping."""
+    return {}
+
+
+@dataclass(frozen=True)
+class CandidateResult:
+    """Result of evaluating a candidate under a policy.
+
+    Contains computed scores and optional derived representations
+    for interpretation or visualization.
+
+    Attributes:
+        candidate: The evaluated candidate.
+        scores: Mapping of label to numeric score.
+        levels: Optional mapping of label to qualitative level
+            (e.g., "low", "medium", "high").
+        visual_levels: Optional mapping of label to presentation-oriented
+            categories (e.g., for UI color or grouping).
+    """
+
+    candidate: Candidate
+    scores: dict[str, float]
+    levels: dict[str, str] = field(default_factory=_default_levels)
+    visual_levels: dict[str, str] = field(default_factory=_default_visual_levels)

multidimensional_evaluation_engine/evaluation/__init__.py

@@ -0,0 +1 @@
+"""Evaluation logic for exploration outputs."""

multidimensional_evaluation_engine/evaluation/evaluator.py

@@ -0,0 +1,58 @@
+"""evaluation/evaluator.py: Evaluate candidates against policy."""
+
+from ..domain.candidates import Candidate
+from ..domain.results import CandidateResult
+from ..policy.policy import Policy
+
+
+def evaluate_candidate(
+    candidate: Candidate,
+    policy: Policy,
+) -> CandidateResult:
+    """Evaluate a candidate under a policy.
+
+    Computes weighted scores for each label defined in the policy.
+
+    Args:
+        candidate: Candidate with dimension values.
+        policy: Policy defining scales and weights.
+
+    Returns:
+        CandidateResult containing computed scores.
+
+    Raises:
+        KeyError: If a required dimension is missing from the candidate.
+        KeyError: If a dimension is not defined in the policy scales.
+        KeyError: If a candidate value is not defined in the corresponding scale.
+    """
+    scores: dict[str, float] = {}
+
+    for label, weights in policy.weights.items():
+        total = 0.0
+
+        for dimension, weight in weights.items():
+            if dimension not in candidate.dimensions:
+                raise KeyError(
+                    f"Candidate {candidate.candidate_id!r} is missing dimension {dimension!r}."
+                )
+
+            value = candidate.dimensions[dimension]
+
+            if dimension not in policy.scales:
+                raise KeyError(f"Policy is missing scale for dimension {dimension!r}.")
+
+            if value not in policy.scales[dimension]:
+                raise KeyError(
+                    f"Unknown value {value!r} for dimension {dimension!r} "
+                    f"in candidate {candidate.candidate_id!r}."
+                )
+
+            numeric = policy.scales[dimension][value]
+            total += float(numeric) * float(weight)
+
+        scores[label] = round(total, 3)
+
+    return CandidateResult(
+        candidate=candidate,
+        scores=scores,
+    )

multidimensional_evaluation_engine/io/__init__.py

@@ -0,0 +1 @@
+"""Input and output helpers."""

multidimensional_evaluation_engine/io/load_candidates.py

@@ -0,0 +1,69 @@
+"""io/load_candidates.py: Load candidates from CSV."""
+
+import csv
+from pathlib import Path
+
+from ..domain.candidates import Candidate
+from ..utils.logging_utils import get_logger
+
+logger = get_logger(__name__)
+
+# CSV contract (local to loader):
+_REQUIRED_COLUMNS = {"candidate_id", "candidate_name"}
+_RESERVED_COLUMNS = {"candidate_id", "candidate_name", "notes"}
+
+
+def load_candidates(csv_path: Path) -> list[Candidate]:
+    """Load candidates from a CSV file.
+
+    Args:
+        csv_path: Path to the CSV file.
+
+    Returns:
+        List of Candidate objects.
+
+    Raises:
+        ValueError: If required columns are missing.
+    """
+    logger.info(f"Loading candidates from: {csv_path}")
+    candidates: list[Candidate] = []
+
+    with csv_path.open("r", encoding="utf-8", newline="") as file:
+        reader = csv.DictReader(file)
+
+        if reader.fieldnames is None:
+            raise ValueError("CSV file must include a header row.")
+
+        headers = [header.strip() for header in reader.fieldnames]
+
+        missing = _REQUIRED_COLUMNS - set(headers)
+        if missing:
+            missing_str = ", ".join(sorted(missing))
+            raise ValueError(f"CSV file is missing required columns: {missing_str}")
+
+        dimension_headers = [
+            header for header in headers if header not in _RESERVED_COLUMNS
+        ]
+
+        for row in reader:
+            cleaned_row = {
+                key.strip(): (value.strip() if value is not None else "")
+                for key, value in row.items()
+                if key is not None
+            }
+
+            dimensions = {
+                header: cleaned_row.get(header, "") for header in dimension_headers
+            }
+
+            candidates.append(
+                Candidate(
+                    candidate_id=cleaned_row["candidate_id"],
+                    candidate_name=cleaned_row["candidate_name"],
+                    dimensions=dimensions,
+                    notes=cleaned_row.get("notes", ""),
+                )
+            )
+
+    logger.info(f"Loaded {len(candidates)} candidates.")
+    return candidates

multidimensional_evaluation_engine/io/load_policy.py

@@ -0,0 +1,44 @@
+"""io/load_policy.py: Load policy from TOML."""
+
+from pathlib import Path
+import tomllib
+
+from ..policy.policy import Policy
+from ..utils.logging_utils import get_logger
+
+logger = get_logger(__name__)
+
+
+def load_policy(path: Path) -> Policy:
+    """Load a policy from a TOML file.
+
+    Args:
+        path: Path to TOML policy file.
+
+    Returns:
+        Policy instance.
+
+    Raises:
+        FileNotFoundError: If the file does not exist.
+        tomllib.TOMLDecodeError: If TOML parsing fails.
+        KeyError: If required policy fields are missing.
+    """
+    logger.info(f"Loading policy from: {path}")
+
+    if not path.exists():
+        raise FileNotFoundError(f"Policy file not found: {path}")
+
+    with path.open("rb") as f:
+        data = tomllib.load(f)
+
+    # Minimal structural validation (core-level only)
+    required = {"scales", "weights", "interpretation"}
+    missing = required - set(data)
+    if missing:
+        missing_str = ", ".join(sorted(missing))
+        raise KeyError(f"Policy is missing required sections: {missing_str}")
+
+    policy = Policy.from_dict(data)
+
+    logger.info("Policy loaded successfully.")
+    return policy

multidimensional_evaluation_engine/policy/__init__.py

@@ -0,0 +1 @@
+"""Policy definitions and loaders."""

multidimensional_evaluation_engine/policy/policy.py

@@ -0,0 +1,62 @@
+"""policy/policy.py: Policy models for multidimensional evaluation."""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+def _default_patterns() -> list[dict[str, Any]]:
+    """Return default empty pattern list."""
+    return []
+
+
+def _default_rules() -> list[dict[str, Any]]:
+    """Return default empty rule list."""
+    return []
+
+
+def _default_metadata() -> dict[str, str]:
+    """Return default empty metadata map."""
+    return {}
+
+
+@dataclass(frozen=True)
+class Policy:
+    """Configuration for multidimensional evaluation.
+
+    A policy defines how candidate dimension values are mapped to numeric
+    scores and how those scores are aggregated.
+
+    Attributes:
+        scales: Mapping of dimension -> categorical value -> numeric score.
+        weights: Mapping of label -> dimension -> weight used in aggregation.
+        interpretation: Thresholds for mapping numeric scores to qualitative levels.
+        patterns: Optional descriptive patterns associated with configurations.
+        rules: Optional rule definitions for annotations or warnings.
+        metadata: Optional auxiliary information not used in scoring.
+    """
+
+    scales: dict[str, dict[str, int | float]]
+    weights: dict[str, dict[str, float]]
+    interpretation: dict[str, float]
+    patterns: list[dict[str, Any]] = field(default_factory=_default_patterns)
+    rules: list[dict[str, Any]] = field(default_factory=_default_rules)
+    metadata: dict[str, str] = field(default_factory=_default_metadata)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Policy":
+        """Create a Policy from a dictionary.
+
+        Args:
+            data: Parsed policy configuration (e.g., from TOML).
+
+        Returns:
+            Policy instance.
+        """
+        return cls(
+            scales=data["scales"],
+            weights=data["weights"],
+            interpretation=data["interpretation"],
+            patterns=data.get("patterns", []),
+            rules=data.get("rules", []),
+            metadata=data.get("metadata", {}),
+        )

multidimensional_evaluation_engine/py.typed

@@ -0,0 +1,22 @@
+# FILE: src/datafun_toolkit/py.typed
+
+# REQ.TYPING:
+#   Mark this package as providing inline type hints (PEP 561).
+
+# WHY.TYPING:
+#   Type checkers (e.g., Pyright, Mypy) only trust type hints in installed
+#   packages if this marker file is present.
+
+# OBS.TYPING:
+#   - This file is required by PEP 561.
+#   - The filename MUST be exactly "py.typed".
+#   - This is a marker file, not Python code.
+#   - The file may be empty; comments are allowed.
+
+# REQ.LOCATION:
+#   Place this file in the top-level package directory
+#   (e.g., src/datafun_toolkit/).
+
+# WHY.LOCATION:
+#   This tells type checkers that ALL modules in this package
+#   should be treated as typed.

multidimensional_evaluation_engine/reporting/tables.py

@@ -0,0 +1,35 @@
+"""reporting/tables.py: Simple text-table reporting for scored results."""
+
+from ..domain.results import CandidateResult
+
+
+def format_results(results: list[CandidateResult]) -> str:
+    """Format evaluation results as a plain-text report.
+
+    Produces a deterministic, human-readable summary of scores and
+    optional qualitative levels for each candidate.
+
+    Args:
+        results: List of candidate evaluation results.
+
+    Returns:
+        Formatted string suitable for console output or logging.
+    """
+    lines: list[str] = []
+
+    for r in results:
+        lines.append(f"{r.candidate.candidate_id} | {r.candidate.candidate_name}")
+
+        # Deterministic ordering for stable output
+        for label in sorted(r.scores):
+            score = r.scores[label]
+            level = r.levels.get(label)
+
+            if level:
+                lines.append(f"  - {label}: {score:.2f} ({level})")
+            else:
+                lines.append(f"  - {label}: {score:.2f}")
+
+        lines.append("")
+
+    return "\n".join(lines).rstrip()

multidimensional_evaluation_engine/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility helpers for the project."""

multidimensional_evaluation_engine/utils/logging_utils.py

@@ -0,0 +1,62 @@
+"""utils/logging_utils.py: Logging helpers for the project."""
+
+import logging
+from pathlib import Path
+
+PROJECT_LOGGER_NAME = "multidimensional_evaluation_engine"
+
+
+def get_logger(name: str | None = None, level: str = "INFO") -> logging.Logger:
+    """Return a configured project logger.
+
+    Args:
+        name: Optional child logger name.
+        level: Logging level for the root project logger.
+
+    Returns:
+        Logger instance scoped to the project.
+    """
+    logger = logging.getLogger(PROJECT_LOGGER_NAME)
+
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(
+            "%(asctime)s | %(levelname)s | %(name)s | %(message)s"
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+    logger.setLevel(level)
+
+    if name:
+        return logger.getChild(name)
+    return logger
+
+
+def log_header(title: str, logger: logging.Logger | None = None) -> None:
+    """Log a section header.
+
+    Args:
+        title: Header text.
+        logger: Logger to use (defaults to project logger).
+    """
+    active_logger = logger or get_logger()
+    active_logger.info("=" * 60)
+    active_logger.info(title)
+    active_logger.info("=" * 60)
+
+
+def log_path(
+    name: str,
+    path: Path | str,
+    logger: logging.Logger | None = None,
+) -> None:
+    """Log a filesystem path.
+
+    Args:
+        name: Label for the path.
+        path: Filesystem path.
+        logger: Logger to use (defaults to project logger).
+    """
+    active_logger = logger or get_logger()
+    active_logger.info(f"{name}: {Path(path)}")

multidimensional_evaluation_engine-0.1.0.dist-info/METADATA

@@ -0,0 +1,175 @@
+Metadata-Version: 2.4
+Name: multidimensional-evaluation-engine
+Version: 0.1.0
+Summary: Core engine for multidimensional evaluation under explicit policy assumptions.
+Author: Denise Case
+License: MIT
+Project-URL: Documentation, https://civic-interconnect.github.io/multidimensional-evaluation-engine/
+Project-URL: Issues, https://github.com/civic-interconnect/multidimensional-evaluation-engine/issues
+Project-URL: Repository, https://github.com/civic-interconnect/multidimensional-evaluation-engine
+Keywords: multidimensional evaluation,policy modeling,tradeoff analysis,decision support,structured evaluation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Typing :: Typed
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: bandit>=1.9.4; extra == "dev"
+Requires-Dist: deptry>=0.24.0; extra == "dev"
+Requires-Dist: packaging>=26.0; extra == "dev"
+Requires-Dist: pre-commit>=4.5.1; extra == "dev"
+Requires-Dist: pytest>=9.0.2; extra == "dev"
+Requires-Dist: pytest-cov>=7.0.0; extra == "dev"
+Requires-Dist: pyright>=1.1.408; extra == "dev"
+Requires-Dist: ruff>=0.14.13; extra == "dev"
+Requires-Dist: validate-pyproject>=0.24.1; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocstrings[python]; extra == "docs"
+Requires-Dist: zensical; extra == "docs"
+Dynamic: license-file
+
+# multidimensional-evaluation-engine
+
+[![PyPI version](https://img.shields.io/pypi/v/multidimensional-evaluation-engine)](https://pypi.org/project/multidimensional-evaluation-engine/)
+[![Latest Release](https://img.shields.io/github/v/release/civic-interconnect/multidimensional-evaluation-engine)](https://github.com/civic-interconnect/multidimensional-evaluation-engine/releases)
+[![Docs](https://img.shields.io/badge/docs-GitHub%20Pages-blue)](https://civic-interconnect.github.io/multidimensional-evaluation-engine/)
+[![CI Status](https://github.com/civic-interconnect/multidimensional-evaluation-engine/actions/workflows/ci-python-zensical.yml/badge.svg?branch=main)](https://github.com/civic-interconnect/multidimensional-evaluation-engine/actions/workflows/ci-python-zensical.yml)
+[![Deploy-Docs](https://github.com/civic-interconnect/multidimensional-evaluation-engine/actions/workflows/deploy-zensical.yml/badge.svg?branch=main)](https://github.com/civic-interconnect/multidimensional-evaluation-engine/actions/workflows/deploy-zensical.yml)
+[![Check Links](https://github.com/civic-interconnect/multidimensional-evaluation-engine/actions/workflows/links.yml/badge.svg)](https://github.com/civic-interconnect/multidimensional-evaluation-engine/actions/workflows/links.yml)
+[![Dependabot](https://img.shields.io/badge/Dependabot-enabled-brightgreen.svg)](https://github.com/civic-interconnect/multidimensional-evaluation-engine/security)
+[![Python 3.14+](https://img.shields.io/badge/python-3.14%2B-blue?logo=python)](#)
+[![MIT](https://img.shields.io/badge/license-see%20LICENSE-yellow.svg)](./LICENSE)
+
+> A domain-neutral engine for multidimensional evaluation under explicit policy assumptions.
+
+
+## What the Engine Does
+
+The engine:
+
+- applies a configurable policy
+- evaluates candidate configurations
+- computes weighted scores across dimensions
+- interprets scores into qualitative levels
+- supports structured comparison across alternative designs
+
+The system is designed to make assumptions explicit and results inspectable.
+
+## Important Note
+
+This project does not advocate for a specific solution.
+
+It provides a structured way to examine:
+
+- how design choices affect outcomes
+- where tradeoffs become significant
+- how governance assumptions shape results
+
+## This Project
+
+This project provides a reusable framework for multidimensional evaluation under explicit assumptions and constraints.
+It:
+
+- supports policy-driven evaluation across multiple domains
+- makes tradeoffs visible through configurable dimensions, scales, and weights
+- separates evaluation logic from domain-specific explorer interfaces
+
+The goal is to provide a stable core that can support multiple exploratory systems built on a shared evaluation model.
+
+## Contribution
+
+The contribution is the engine for structured multidimensional evaluation, not the specific values used in any given scenario.
+
+- Dimensions, scales, weights, and thresholds are configurable
+- Assumptions are explicit and inspectable
+- Results are comparative and scenario-dependent
+- The core logic is domain-neutral
+
+This project does not determine outcomes or recommend decisions.
+It provides a way to examine how different assumptions and constraints shape results.
+
+## Working Files
+
+Working files are found in these areas:
+
+- **docs/** - documentation and examples
+- **src/** - implementation
+
+## Capabilities
+
+- Loads policy configuration structures
+- Evaluates candidate configurations across weighted dimensions
+- Computes score profiles and qualitative levels
+- Supports reusable integration into domain-specific explorer systems
+
+## Command Reference
+
+<details>
+<summary>Show command reference</summary>
+
+### In a machine terminal (open in your `Repos` folder)
+
+After you get a copy of this repo in your own GitHub account,
+open a machine terminal in your `Repos` folder:
+
+```shell
+# Replace username with YOUR GitHub username.
+git clone https://github.com/username/multidimensional-evaluation-engine
+
+cd multidimensional-evaluation-engine
+code .
+```
+
+### In a VS Code terminal
+
+```shell
+uv self update
+uv python pin 3.14
+uv sync --extra dev --extra docs --upgrade
+
+uvx pre-commit install
+git add -A
+uvx pre-commit run --all-files
+# repeat if changes were made
+git add -A
+uvx pre-commit run --all-files
+
+uv run ruff format --check .
+uv run ruff check .
+uv run pytest --cov=src --cov-report=term-missing
+
+uv run deptry .
+uv run bandit -c pyproject.toml -r src
+uv run validate-pyproject pyproject.toml
+uv run zensical build
+
+git add -A
+git commit -m "update"
+git push -u origin main
+```
+
+</details>
+
+## Annotations
+
+[ANNOTATIONS.md](./ANNOTATIONS.md)
+
+## Citation
+
+[CITATION.cff](./CITATION.cff)
+
+## License
+
+[MIT](./LICENSE)
+
+## SE Manifest
+
+[SE_MANIFEST.md](./SE_MANIFEST.toml)

multidimensional_evaluation_engine-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+multidimensional_evaluation_engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+multidimensional_evaluation_engine/_version.py,sha256=n_5vdJsPNu7wZ57LGuRL585uvll-hiuvZUBWzdG0RQU,520
+multidimensional_evaluation_engine/py.typed,sha256=PVMQRODHuXaoq_Jd0G4SMYyajSR3oIKYfuRykCUOuCw,667
+multidimensional_evaluation_engine/domain/__init__.py,sha256=4M__LeQqeDBbNjkDOnoLOYoyrHVrs4pJesV2Prs6jpw,21
+multidimensional_evaluation_engine/domain/candidates.py,sha256=cp6AuYmnecpjSvnclF44TilGm9IMXV3W_pPczCKGz9k,944
+multidimensional_evaluation_engine/domain/results.py,sha256=lJEn00VLDZYc1j6F-rl9w-Q9JsK8BP6ov8GtYMqf8no,1141
+multidimensional_evaluation_engine/evaluation/__init__.py,sha256=rvwbL6675_7A5j0BxoHmEqfwc0Z8oLcWC_HQqVxeylo,48
+multidimensional_evaluation_engine/evaluation/evaluator.py,sha256=8wWRSiylYql7x4i8woyEeDfDQbsr7YAU1WPM6STWzx4,1848
+multidimensional_evaluation_engine/io/__init__.py,sha256=DY52HsekcLvdkvbVcm9vCccZQ0PmlYM6Zcuk-TEe6w0,32
+multidimensional_evaluation_engine/io/load_candidates.py,sha256=hMLcfaAOoj-OxZfDXQxCRXYfBZxcAmQM2EuAZhcnUL0,2087
+multidimensional_evaluation_engine/io/load_policy.py,sha256=X7blvYGf-mP3nwlxCxQxoCRCWyy1X96FK0qXwdc0RTA,1155
+multidimensional_evaluation_engine/policy/__init__.py,sha256=x7dxybXvdgS_DAPMqO6VszvSwb7U6IhjJwocZgl3ZcQ,38
+multidimensional_evaluation_engine/policy/policy.py,sha256=9_eqzidNJNnzN6WqMKlOkAyyZ0ZuHe6i-2L2d_cMGcw,2051
+multidimensional_evaluation_engine/reporting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+multidimensional_evaluation_engine/reporting/tables.py,sha256=AKmWSCoEtsRnYC-nrA01HaePGuahwNQU2lPuEt7JndY,1042
+multidimensional_evaluation_engine/utils/__init__.py,sha256=_-_DIeAuch4rSVvtrH6hPJaReen-hiM1kVEV46GL8iU,39
+multidimensional_evaluation_engine/utils/logging_utils.py,sha256=sM0VEk9xUwkFcDqZxZPI0gP6eoXLY5Jld8waO0VJYIQ,1602
+multidimensional_evaluation_engine-0.1.0.dist-info/licenses/LICENSE,sha256=fRFn0da07ZexkL7FGPthxrSvl1ykev5s38AFH49Ppbw,1071
+multidimensional_evaluation_engine-0.1.0.dist-info/METADATA,sha256=dQho1ANbH5pQvxF_5mDY6svbNZ-EKqxWQwSM8tGDdEs,6517
+multidimensional_evaluation_engine-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+multidimensional_evaluation_engine-0.1.0.dist-info/top_level.txt,sha256=g5MvanuQCLLXPIV6hRupMBmxQz8mQt3P18uWMR4Za5M,35
+multidimensional_evaluation_engine-0.1.0.dist-info/RECORD,,

multidimensional_evaluation_engine-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
+

multidimensional_evaluation_engine-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Denise M. Case
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

multidimensional_evaluation_engine-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+multidimensional_evaluation_engine