codecaliper 0.1.0__py3-none-any.whl

codecaliper/syntax/tokens.py

@@ -0,0 +1,165 @@
+"""The unified lexical token stream (TOK-* rulings).
+
+Derived from the tree-sitter leaf walk (with atomic-token subtrees) and
+classified by the adapter's token tables. This one stream feeds the BW
+readability features, lexical Halstead, and the LOC coverage counts — one
+tokenizer, three consumers, zero drift.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from codecaliper.model import Diagnostic
+from codecaliper.spec import iter_rulings, require
+
+if TYPE_CHECKING:  # pragma: no cover
+    from codecaliper.languages.base import LanguageAdapter
+    from codecaliper.syntax._treesitter import Tree
+
+R_ANON_WORD = require("TOK-ALL-0007")  # anonymous word tokens are identifiers
+
+
+class TokenKind(Enum):
+    IDENTIFIER = "identifier"
+    KEYWORD = "keyword"
+    NUMBER = "number"
+    STRING = "string"
+    COMMENT = "comment"
+    OPERATOR = "operator"
+    PUNCT = "punct"
+    OTHER = "other"
+
+
+@dataclass(frozen=True, slots=True)
+class LexicalToken:
+    kind: TokenKind
+    text: str
+    line: int  # 1-based physical line of the token start (TOK-ALL-0005)
+    end_line: int  # 1-based line of the token end (span coverage for sloc/cloc)
+
+
+_PUNCT = frozenset({"(", ")", "[", "]", "{", "}", ",", ".", ";", ":"})
+
+# Word-shaped anonymous tokens (TOK-ALL-0007): identifier-shaped, with internal
+# hyphens allowed for Java's hyphenated contextual keyword (`non-sealed`).
+_WORD_RE = re.compile(r"[^\W\d]\w*(?:-\w+)*", re.UNICODE)
+
+
+def normalize(source: str | bytes) -> tuple[str, tuple[Diagnostic, ...]]:
+    """Input normalization per TOK-ALL-0001..0003."""
+    diags: list[Diagnostic] = []
+    if isinstance(source, bytes):
+        # the diagnostic fires only when replacement actually happened — valid
+        # UTF-8 that legitimately contains U+FFFD is not flagged
+        try:
+            text = source.decode("utf-8")
+        except UnicodeDecodeError:
+            text = source.decode("utf-8", errors="replace")
+            diags.append(
+                Diagnostic("warning", "encoding-replaced",
+                           "undecodable bytes replaced with U+FFFD", ruling="TOK-ALL-0001")
+            )
+    else:
+        text = source
+    if text.startswith(""):
+        text = text[1:]
+        diags.append(
+            Diagnostic("info", "bom-stripped", "leading UTF-8 BOM stripped", ruling="TOK-ALL-0002")
+        )
+    text = text.replace("\r\n", "\n").replace("\r", "\n")
+    return text, tuple(diags)
+
+
+def source_lines(text: str) -> list[str]:
+    """Physical lines; a trailing final newline does not create an extra empty
+    line (LOC-ALL-0001, and the BW reference's convention)."""
+    lines = text.split("\n")
+    if lines and lines[-1] == "":
+        lines = lines[:-1]
+    return lines
+
+
+def lang_tokenization_rulings(adapter: LanguageAdapter) -> tuple[str, ...]:
+    """The language's STATIC tokenization rulings: the atomic-string rules
+    (TOK-PY-0002 / TOK-JAVA-0001) that unconditionally govern how the stream is
+    cut, so every token-derived value cites them. Construct-specific
+    classification rulings (``adapter.conditional_token_rulings``, e.g.
+    TOK-JAVA-0002) are excluded — they are cited per-occurrence, like the
+    language-neutral TOK-ALL-0007, not statically."""
+    conditional = set(adapter.conditional_token_rulings.values())
+    return tuple(sorted(
+        r.id
+        for r in iter_rulings(metric="tokenization", language=adapter.name)
+        if r.language == adapter.name and r.status == "active"
+        and r.id not in conditional
+    ))
+
+
+def lex(
+    tree: Tree,
+    source_bytes: bytes,
+    adapter: LanguageAdapter,
+    *,
+    include_error_tokens: bool = False,
+    cond_lines: dict[str, set[int]] | None = None,
+) -> list[LexicalToken]:
+    """Classify the leaf stream via the adapter's token tables.
+
+    ``include_error_tokens=True`` descends into ERROR subtrees (BW-ALL-0007:
+    the BW construct is lexical); the default stream is error-opaque
+    (CORE-ALL-0002) and feeds every metric. ``cond_lines``, when given, records
+    for each conditional tokenization ruling the physical lines where it
+    engaged (TOK-ALL-0007 anonymous words; the adapter's
+    ``conditional_token_rulings``, e.g. TOK-JAVA-0002 `_`), so provenance can
+    cite it per-occurrence and per-unit rather than file-globally.
+    """
+    from codecaliper.syntax._treesitter import leaves, leaves_lexical, node_text
+
+    iterator = leaves_lexical if include_error_tokens else leaves
+    out: list[LexicalToken] = []
+    for node in iterator(tree, adapter.atomic_types):
+        ttype = node.type
+        if ttype in ("ERROR",) or node.is_missing:
+            continue
+        text = node_text(node, source_bytes)
+        if not text:
+            continue
+        line = node.start_point[0] + 1
+        end_line = node.end_point[0] + 1
+        if ttype in adapter.comment_types:
+            kind = TokenKind.COMMENT
+        elif ttype in adapter.string_types:
+            kind = TokenKind.STRING
+        elif ttype in adapter.number_types:
+            kind = TokenKind.NUMBER
+        elif ttype in adapter.keyword_leaf_types or text in adapter.keywords:
+            kind = TokenKind.KEYWORD
+        elif ttype in adapter.identifier_types:
+            kind = TokenKind.IDENTIFIER
+        elif ttype in adapter.operator_leaf_types:
+            # named leaves that are operator tokens (Python `...`, TOK-PY-0003),
+            # so they are not swallowed by the is_named -> OTHER fallthrough
+            kind = TokenKind.OPERATOR
+        elif not node.is_named and text in adapter.soft_keywords:
+            kind = TokenKind.IDENTIFIER  # soft keywords are identifiers (BW-PY-0001)
+        elif not node.is_named and _WORD_RE.fullmatch(text) is not None:
+            # TOK-ALL-0007: anonymous word tokens outside the keyword table are
+            # identifiers (Python `__future__`, Java contextual keywords) —
+            # matching the reference tokenizers, which yield NAME for them.
+            kind = TokenKind.IDENTIFIER
+            if cond_lines is not None:
+                cond_lines.setdefault(R_ANON_WORD, set()).add(line)
+        elif node.is_named:
+            kind = TokenKind.OTHER
+        elif text in _PUNCT:
+            kind = TokenKind.PUNCT
+        else:
+            kind = TokenKind.OPERATOR
+        if cond_lines is not None and ttype in adapter.conditional_token_rulings:
+            cond_lines.setdefault(adapter.conditional_token_rulings[ttype], set()).add(line)
+        out.append(LexicalToken(kind, text, line, end_line))
+    return out

codecaliper-0.1.0.dist-info/METADATA

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: codecaliper
+Version: 0.1.0
+Summary: A cross-language code readability + complexity measurement instrument with a versioned metric-to-syntax specification
+Project-URL: Repository, https://github.com/KurathSec/codecaliper
+Project-URL: Documentation, https://kurathsec.github.io/codecaliper/
+Project-URL: Issues, https://github.com/KurathSec/codecaliper/issues
+Project-URL: Changelog, https://github.com/KurathSec/codecaliper/blob/main/CHANGELOG.md
+Author-email: Yuxiang Ji <kurathandrew@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+License-File: NOTICE
+Keywords: buse-weimer,code metrics,cognitive complexity,cyclomatic complexity,halstead,maintainability index,measurement instrument,mining software repositories,readability,tree-sitter
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+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 :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: tomli>=2.0; python_version < '3.11'
+Requires-Dist: tree-sitter-java<0.24,>=0.23.5
+Requires-Dist: tree-sitter-python<0.26,>=0.25
+Requires-Dist: tree-sitter<0.27,>=0.25
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.6; extra == 'docs'
+Requires-Dist: mkdocs>=1.6; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=1.0; extra == 'docs'
+Provides-Extra: oracles
+Requires-Dist: cognitive-complexity>=1.3; extra == 'oracles'
+Requires-Dist: lizard>=1.17; extra == 'oracles'
+Requires-Dist: radon>=6; extra == 'oracles'
+Provides-Extra: retrain
+Requires-Dist: scikit-learn>=1.4; extra == 'retrain'
+Description-Content-Type: text/markdown
+
+# codecaliper
+
+[![ci](https://github.com/KurathSec/codecaliper/actions/workflows/ci.yml/badge.svg)](https://github.com/KurathSec/codecaliper/actions/workflows/ci.yml)
+[![docs](https://github.com/KurathSec/codecaliper/actions/workflows/docs.yml/badge.svg)](https://kurathsec.github.io/codecaliper/)
+
+> A cross-language (Python + Java, more staged) **code-readability + complexity
+> measurement instrument** — not another metrics scoreboard.
+> Documentation: <https://kurathsec.github.io/codecaliper/>
+
+codecaliper is built as an *instrument*: every number it emits is **traceable**
+— to a versioned metric-to-syntax specification, to the exact machine-readable
+rulings that fired, to the exact tree-sitter grammar that parsed the source —
+and **reproducible** — clock-free, hash-seed-free, order-stable. Where a
+scoreboard says "CC = 7", codecaliper says "CC = 7 *under spec 1.1.0, ruling
+CC-PY-0003, tree-sitter-python 0.25.0*".
+
+## What it measures
+
+- **Readability (the core):** the first open, tested, cross-language
+  implementation of the **Buse–Weimer (2010) 25-feature readability set**,
+  computed on tree-sitter (comments and positions preserved). Output is always
+  the **raw feature vector** — there is deliberately no "readability score" —
+  plus a retraining scaffold. Scalabrino/Dorn feature sets are staged for 1.x.
+- **Complexity (a convenience, not the selling point):** cyclomatic,
+  **dual-mode cognitive complexity** (whitepaper-faithful by default,
+  `--sonar-compat` opt-in, every divergence between the modes is an enumerable
+  spec ruling), Halstead (a declared lexical approximation), maintainability
+  index (typed as *derived from* CC — never an independent signal), and the
+  LOC family.
+
+## Why an instrument
+
+Different tools disagree on the same file because each is a different
+*operationalization* of the same construct (radon vs lizard cyclomatic; the
+per-language cognitive-complexity ports; every hand-rolled Buse–Weimer
+extractor in the literature). codecaliper's answer:
+
+1. a **versioned mapping specification** — machine-readable rulings with
+   immutable IDs (`CC-PY-0003`), shipped as package data, stamped into every
+   result;
+2. a **hand-computed consistency corpus** — every active ruling is exercised by
+   a case with human-verified expected values;
+3. **differential tests** against radon / lizard / cognitive_complexity with
+   a **published known-divergence list** — every disagreement is classified
+   against a ruling, in both directions (an unclassified divergence fails CI,
+   and so does a stale entry); PMD and rust-code-analysis are staged as
+   additional oracles;
+4. a **faithfulness reproduction** of the original Buse–Weimer study (100 Java
+   snippets, 120 annotators) using this extractor and a retrained model.
+
+## Honesty boundaries
+
+codecaliper guarantees **procedural consistency** (identical rules over
+isomorphic syntax across languages), *not* cross-language numerical
+comparability. MI contains CC. Halstead absolute values are
+implementation-defined. BW output is a feature set, not a score, calibrated on
+4–11-line snippets — function/file vectors are labelled extrapolation. Metrics
+operate on pre-preprocessing source text. Every one of these is enforced in the
+result types, not just stated here.
+
+## Install
+
+```bash
+pip install codecaliper          # (not yet on PyPI — install from source for now)
+pip install -e .                 # from a checkout
+```
+
+## Use
+
+```bash
+codecaliper myfile.py --json
+codecaliper src/**/*.java --csv -o metrics.csv
+codecaliper myfile.py --sonar-compat --explain
+codecaliper spec show CC-PY-0003     # read the ruling behind a number
+codecaliper env                      # the calibration plate for bug reports/papers
+codecaliper cite                     # methods-section template
+```
+
+```python
+from codecaliper import measure
+
+report = measure(source_code, language="python")
+cc = next(m for m in report.file_metrics if m.metric == "cyclomatic")
+print(cc.value, cc.rulings, report.provenance.spec_version)
+
+vec = report.readability[0]          # raw BW 25-feature vector — never a score
+print(dict(zip(vec.names, vec.values)), vec.extrapolated)
+```
+
+## Status
+
+Spec **v1.1.0** (package 0.1.0.dev0 — the spec and package are versioned
+independently): Python + Java wired end-to-end; every active ruling is
+exercised by a hand-computed corpus case; mypy --strict and the differential
+oracle lane (radon/lizard/cognitive_complexity, classified divergence list)
+are hard CI gates. The BW faithfulness reproduction ran on the original
+100-snippet dataset: 10-fold logistic accuracy 0.820 (bootstrap 95% CI
+[0.770, 0.870], overlapping the paper's ~0.80), AUC 0.828, Fig. 9 sign
+agreement 21/24 — after a pre-registered arbitration experiment resolved two
+feature-definition ambiguities (indentation tab width; lexical fallback on
+parse errors) as versioned ruling supersessions (see
+`validation/bw_faithfulness/derived/`). The
+[docs site](https://kurathsec.github.io/codecaliper/) and the tag-triggered
+release pipeline (PyPI trusted publishing + Zenodo archival, `RELEASING.md`)
+are in place; next: the first tagged release (v0.1.0 + DOI) and the MSR
+Data & Tool Showcase paper (`ARCHITECTURE.md` §16, W8).
+
+## Development
+
+```bash
+pip install -e ".[dev]" -c constraints/ci.txt
+pytest
+ruff check src tests tools
+```
+
+See `ARCHITECTURE.md` for the full design (data model, spec mechanism,
+validation architecture, grammar-evolution policy) and `CONTRIBUTING.md` for
+how rulings, corpus cases, and adapters are added.
+
+## Citing
+
+Citation metadata lives in
+[`CITATION.cff`](https://github.com/KurathSec/codecaliper/blob/main/CITATION.cff)
+(GitHub's "Cite this repository" box reads it; Zenodo archives releases from
+it).
+`codecaliper cite` prints a methods-section template stating the package,
+spec, and grammar versions your numbers were produced under — report all
+three.
+
+## License & provenance
+
+MIT. Some measurement primitives descend from
+[Spaghetti Architect](https://doi.org/10.5281/zenodo.21033174) (same author) —
+see `NOTICE`.

codecaliper-0.1.0.dist-info/RECORD

@@ -0,0 +1,46 @@
+codecaliper/__init__.py,sha256=wT2JL3MXQEbZEeComy9hNlTfc2I85ikyrp7iE0FCBhw,1690
+codecaliper/_version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+codecaliper/api.py,sha256=6M4eb4Tm7QRlQ-qnrC3euBqtVO3HM1DXoSowsGo5fLQ,18384
+codecaliper/canonical.py,sha256=-IzyNckvvl_a91T3LXqtaftBh-KjS1-FfqWBYzPQjXo,4766
+codecaliper/cli.py,sha256=ru4PiJ-7FKXrWsHz3KYkPrFJEZ3qKeTMLdT4Frw5y_8,8986
+codecaliper/errors.py,sha256=TAg0RWSlmUYBB7oJZ0jIrVQn9xJVBhf3Wg7bMj7iICQ,811
+codecaliper/model.py,sha256=TadZRdwNhQL_HTu80STGxEkvuGnCwgqXC_07vxBhtx8,4392
+codecaliper/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codecaliper/languages/__init__.py,sha256=CdgZmsjGtyEDbEEc1sKGFNd9U9KBW7YKTxXz9XKCUDQ,1387
+codecaliper/languages/base.py,sha256=vbYEonzJFEzTiNEmRYYf19hIAKWX4gqcYhY8Sh6Quio,6087
+codecaliper/languages/java.py,sha256=yb53hFc0lbwlgN2_gra8wYesTyWmPerviFG5i3w9VpQ,9853
+codecaliper/languages/python.py,sha256=1U3HmIkrU9Z5nwHJCVimP987AYRbhxYgxXWxRSdil5E,8758
+codecaliper/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codecaliper/metrics/base.py,sha256=Ttsz4mNvjUFsswTf4WjQ11PG9iOhrmqC5v-sxfIvdI4,2297
+codecaliper/metrics/cognitive.py,sha256=FY2yU9GlEpT78SiU9KgxZ2IWjJg66itQQVOugKYTdLU,4880
+codecaliper/metrics/cyclomatic.py,sha256=161PYwmleKReNG9f1kYNHPOTR8aBQ0IlCS9hr1EUmuU,2086
+codecaliper/metrics/halstead.py,sha256=4GHBI36ijMlqnPuKI2ZuzhDRvTfRFhLme9764wj_0xE,2045
+codecaliper/metrics/loc.py,sha256=yEMfPgjuopWPIOEQASnc6SwKANIARYli4GmCTDiQERA,1986
+codecaliper/metrics/mi.py,sha256=Vst5XEwNn_e7LPkONpm-E5HT3l-DuBv1SUVwRU3GYBI,950
+codecaliper/readability/__init__.py,sha256=q2tRja8vtzEiuhJrQT6lzqgNoCpBwSKfU9GhNJ8N29A,292
+codecaliper/readability/base.py,sha256=lZHQfXxtHmLviTaDoXBrYL3bR9VVU7X63_HfjH83H-g,399
+codecaliper/readability/bw2010.py,sha256=JpEn8jNs9lysAS4BfcVa-3BQ7OFLDQJR2OGoc_8jvbY,6188
+codecaliper/readability/granularity.py,sha256=amjGIzsWrWK8JPoKc55jnDB5fmKo1McCBFqrDw9r4hw,8097
+codecaliper/readability/retrain.py,sha256=w1WM5kw1W5uuw6jcWhLWdR-yM0E5HHdKt4vZ0CDFya8,2517
+codecaliper/spec/__init__.py,sha256=fWqCw2gEnyN9UUA4mqobtqUlsyZvgZ0oA7Pop9f5T2k,165
+codecaliper/spec/registry.py,sha256=7l1AAoWfDfOnup7ZKx5X41r-wrIsRmuPGNFeaaTjIjU,3452
+codecaliper/spec/validated_grammars.toml,sha256=0EqnAsjw9w-FDaVUwKdEc3uVL11bRP9XslnJSpBh5vo,269
+codecaliper/spec/rulings/bw.toml,sha256=Q5mDKF2SiuGPYjzTji8jQPnNNwunlqmTrwWoF56g51E,5921
+codecaliper/spec/rulings/cognitive.toml,sha256=cozChgXyWyVCZXaryd8papMskC_6NkHZtjXGGngGzss,4978
+codecaliper/spec/rulings/core.toml,sha256=ZCOG-3k0Lue1rR5Up7YUArdnsZ80KecHUPccwzplTZM,3492
+codecaliper/spec/rulings/cyclomatic.toml,sha256=Sb-zwMNw9IbhV_0rD8o7xaXLNC6zkFOBhJUI50mDcu8,5630
+codecaliper/spec/rulings/halstead.toml,sha256=loFpLbmvn18fJCsS1CbOP2STJdNR6FGk3AKrL4GWgNc,993
+codecaliper/spec/rulings/index.toml,sha256=67A_CUJA7S8De9AsEOoDzwU4_v29iE3UeS9FD7XgJWA,3028
+codecaliper/spec/rulings/loc.toml,sha256=uCLriHAfx6g1w-7p7wU5gZVMfT0Th10TuL6mGmeJ08E,1630
+codecaliper/spec/rulings/mi.toml,sha256=k-29C1KY0K-GZusrAmNHWW4hMNRSrVY-Js6tmTPmptU,565
+codecaliper/spec/rulings/tokenization.toml,sha256=TLMd4jcyWLrK_2S4CxjMHq43XgWsSL4lw-6Y5mHFojw,7716
+codecaliper/syntax/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codecaliper/syntax/_treesitter.py,sha256=Yy-c5sMjgxUOYwqg-99FIW3CqPzNw_8Q2-_Og2kKqTQ,6613
+codecaliper/syntax/grammars.py,sha256=SQ0XZwElLRZrFPVFLkDQgoD5kN49HakkR3VnBy5cFnM,1405
+codecaliper/syntax/tokens.py,sha256=aYMF6MWAnYkkHL4rx-BJzgOqLNru44rUhaxM831RkxQ,6601
+codecaliper-0.1.0.dist-info/METADATA,sha256=e7olri0fdImNG1l1oPLYI6PnhAIL-kE44ZuVafHi5gQ,8261
+codecaliper-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+codecaliper-0.1.0.dist-info/entry_points.txt,sha256=c5CNZiaFhMsPWo4gyhL7yj_iEtphBUzKzM4yn6YuowQ,53
+codecaliper-0.1.0.dist-info/licenses/LICENSE,sha256=JgGBN2SG1F4x-r8tKpJ3u8rU4eST_VHZu_GpESSjKvI,1067
+codecaliper-0.1.0.dist-info/licenses/NOTICE,sha256=szeLMKAvHrFkogcNPh0kFPulUOKrmL5wHtmtpDSC0Lg,1329
+codecaliper-0.1.0.dist-info/RECORD,,

codecaliper-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

codecaliper-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codecaliper = codecaliper.cli:main

codecaliper-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yuxiang Ji
+
+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.

codecaliper-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,29 @@
+codecaliper
+Copyright (c) 2026 Yuxiang Ji
+Licensed under the MIT License (see LICENSE).
+
+Provenance of measurement primitives
+------------------------------------
+
+Several measurement primitives in this repository descend from Spaghetti
+Architect (MIT, same author) and are reused here with attribution:
+
+- The Buse-Weimer (2010) 25-feature reference extractor
+  (tests/_reference/bw_stdlib.py, and the canonical feature order in
+  src/codecaliper/readability/bw2010.py) descends from bench/anchor.py.
+- The Python-AST metric lane used as a test-only differential oracle
+  (tests/_reference/py_ast_lane.py) descends from eval/metrics.py.
+- The "optional oracle probe with honest SKIP" differential-testing pattern
+  descends from bench/anchor.py.
+- The pure-stdlib statistics helpers (spearman, mean, bootstrap CI) used by the
+  BW faithfulness pipeline descend from bench/grade.py.
+
+Please cite Spaghetti Architect via its concept DOI:
+
+  Ji, Yuxiang. Spaghetti Architect: A Contamination-Resistant,
+  By-Construction-Labelled, Multi-Language Code Dataset Generator.
+  https://doi.org/10.5281/zenodo.21033174
+
+codecaliper is a general-purpose measurement instrument for arbitrary user
+source code; it does not ingest Spaghetti Architect's IR, dataset, or
+anti-pattern machinery (anti-salami boundary, see ARCHITECTURE.md §12).