Sample
Select one of ten low-readability unrelated code templates per class
| Method | Score | Scale |
|---|---|---|
| Posnett | 0.405 | 0–1; higher is more readable |
| Dorn | 0.918 | 0–1; higher is more readable |
| Mi | 0.496 | 0–1; higher is more readable |
| LLOC | 6 | Logical lines; fewer is more readable |
| DeepSeek V4 Pro | 16.33 | 0–20; mean of three runs |
| GPT-6.1 Sol | 16.67 | 0–20; mean of three runs |
| BTTF | 0.837 | 0–1; higher is more readable |
Loading feature diagnosis…
| Feature | Value | Contribution (log-odds) |
|---|---|---|
| Byte entropyHow varied the bytes in the source text are. Repeated bytes give a lower value; a more even mixture gives a higher value. | 4.853 | −7.279 |
| Halstead volumeHow much symbolic information the code contains. It combines the total number of operators and values with the number of distinct ones. | 144.754 | −4.777 |
| Source linesThe number of non-empty source lines. | 7 | +2.8 |
Intercept 8.87 + feature contributions = -0.386 (log-odds).
Score = sigmoid(-0.386) = 0.405.
| Feature | Value | Contribution (log-odds) |
|---|---|---|
| Identifier layout (horizontal)How rapidly the visual pattern of identifier characters changes from left to right. It measures spatial frequency, not the meaning of the names. | 59.875 | +1.129 |
| Comment layout frequencyHow frequently the layout switches between lines containing only comments or whitespace and lines containing code. | 8 | +0.753 |
| Operator visual areaThe share of the code’s visual area occupied by operators such as +, =, and *. | 0.024 | +0.713 |
| Indentation frequencyHow rapidly indentation changes from line to line. | 7 | −0.495 |
| Number layout frequencyHow rapidly the number of numeric values per line changes through the code. | 1 | +0.398 |
| Identifier layout (vertical)How rapidly the visual pattern of identifier characters changes from top to bottom. | 6.705 | −0.316 |
| Comment layout (horizontal)How rapidly the visual pattern of comment characters changes from left to right. | 60 | +0.164 |
Intercept 0.07 + feature contributions = 2.416 (log-odds).
Score = sigmoid(2.416) = 0.918.
| Score | 0.496 |
|---|
| Score | 6 |
|---|
The code is well-structured and highly readable. It uses a clear import block with forward compatibility and type-checking support. Class definition is concise with a docstring that clearly states intent. Nesting is virtually nonexistent, and each import/logical action is on its own line. One minor deduction for lack of context: the class is empty but inherits from `RequestException`, and `CompatJSONDecodeError` import is not used in the shown snippet, making purpose slightly ambiguous without surrounding code. Overall, very clean.
The code is highly readable. It has a clear, logical structure: imports at the top, followed by a class definition with a short, concise docstring. Nesting is minimal, and the intent is clear—defining a custom HTTP error exception. The code is concise and avoids unnecessary length. Each import is separated appropriately, and the class definition is straightforward. The only minor point is that the class body is very simple, so there is little to evaluate in terms of action granularity or flow, but overall it is clean and easy to understand.
The code is a short class definition inheriting from RequestException, with a docstring. It has a clear purpose and is concise. However, it is incomplete and ambiguous: RequestException is not imported or defined, HTTPError is imported but unused, and CompatJSONDecodeError is imported but not used, which clutters the code. The structure is logical but the unused imports and undefined base class hinder clarity. Nesting is flat, action granularity is one action per line, and reading flow is natural, but the missing imports make the code unreadable in practice.
Code Structure: Imports precede a clearly defined exception class, giving the snippet a logical organization. Nesting: There is only a single class body, so nesting is minimal. Clarity of intent: The class name and docstring clearly identify an HTTP exception, although RequestException is not defined or imported in the snippet and several imports appear unused. Code length: The implementation is concise, with no unnecessary logic, but unused imports add clutter. Action granularity: Each import and declaration occupies its own line. Reading flow: The top-to-bottom flow is natural; additional spacing between import groups and before the class would improve visual separation.
Code Structure: Imports followed by a single exception class form a straightforward organization, though several imports are unused in the snippet. Nesting: Only the class body is indented, keeping nesting minimal. Clarity of intent: The class name and docstring clearly identify an HTTP exception, but RequestException is neither defined nor imported in the provided code, obscuring its inheritance context. Code length: Very concise, although unused imports add unnecessary clutter. Action granularity: Each import and declaration occupies its own line, with no combined actions. Reading flow: The top-to-bottom flow is natural; an additional blank line before the top-level class would improve conventional Python formatting.
Code Structure: Imports precede a clearly separated exception class, providing logical organization. Nesting: The code is flat except for the class body. Clarity of intent: The class name and docstring clearly identify an HTTP exception, though RequestException is not defined or imported in the snippet, and several imports appear unused. Code length: Very concise, with some potentially unnecessary imports. Action granularity: Each import and declaration occupies its own line. Reading flow: Natural top-to-bottom flow, although an additional blank line before the top-level class would improve conventional Python formatting.