fastaistyle 0.0.5__tar.gz

fastaistyle-0.0.5/.claude/settings.local.json

@@ -0,0 +1,18 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(claude --version)",
+      "Bash(npm update:*)",
+      "Bash(pip install:*)",
+      "Bash(pytest:*)",
+      "Bash(chkstyle --help:*)",
+      "Bash(chkstyle:*)",
+      "Bash(hatch version:*)",
+      "Bash(hatch build:*)",
+      "Bash(gh run list:*)",
+      "Bash(gh run rerun:*)",
+      "Bash(git push)",
+      "Bash(./tools/release.sh)"
+    ]
+  }
+}

fastaistyle-0.0.5/.github/workflows/release.yml

@@ -0,0 +1,18 @@
+name: Release
+on:
+  push:
+    tags: ['v*']
+
+jobs:
+  pypi:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - run: pip install hatch
+      - run: hatch build
+      - uses: pypa/gh-action-pypi-publish@release/v1

fastaistyle-0.0.5/.gitignore

@@ -0,0 +1,146 @@
+_proc/
+sidebar.yml
+Gemfile.lock
+token
+_docs/
+conda/
+.last_checked
+.gitconfig
+*.bak
+*.log
+*~
+~*
+_tmp*
+tmp*
+tags
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# dotenv
+.env
+
+# virtualenv
+.venv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+.vscode
+*.swp
+
+# osx generated files
+.DS_Store
+.DS_Store?
+.Trashes
+ehthumbs.db
+Thumbs.db
+.idea
+
+# pytest
+.pytest_cache
+
+# tools/trust-doc-nbs
+docs_src/.last_checked
+
+# symlinks to fastai
+docs_src/fastai
+tools/fastai
+
+# link checker
+checklink/cookies.txt
+
+# .gitconfig is now autogenerated
+.gitconfig
+
+_docs

fastaistyle-0.0.5/PKG-INFO

@@ -0,0 +1,243 @@
+Metadata-Version: 2.4
+Name: fastaistyle
+Version: 0.0.5
+Summary: Style checker for fast.ai coding conventions
+Project-URL: Homepage, https://github.com/AnswerDotAI/fastaistyle
+Author-email: Jeremy Howard <j@fast.ai>
+License-Expression: Apache-2.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# fastaistyle
+
+```bash
+pip install fastaistyle
+```
+
+A style checker that enforces the [fast.ai coding style](https://docs.fast.ai/dev/style.html)—a compact, readable approach to Python that keeps more code visible on screen and reduces cognitive load.
+
+## Why This Style?
+
+Most style guides optimize for the wrong thing. They add vertical space, mandate verbose names, and scatter related code across many lines. The result? You see less code at once, which means more scrolling, more context-switching, and more mental effort to understand what's happening.
+
+The fast.ai style takes a different approach, rooted in decades of experience with APL, J, K, and scientific programming. The core insight comes from Kenneth Iverson: **"brevity facilitates reasoning."**
+
+### Your Brain Can Only Hold So Much
+
+When you're reading code, your working memory is limited. If a function spans 50 lines, you can't see the whole thing at once. You scroll down, forget what was at the top, scroll back up. Each scroll is a context switch. Each context switch costs mental energy.
+
+But if that same function fits in 15 lines? You see the whole picture. Your eyes can jump between related parts instantly. Patterns become obvious. Bugs stand out.
+
+This isn't about cramming code together—it's about *removing unnecessary vertical space* so your brain can do what it's good at: recognizing patterns across visible information.
+
+### One Line, One Idea
+
+The goal is density without confusion. Each line should express one complete thought:
+
+```python
+# Good: you see the whole pattern at once
+if not data: return None
+for item in items: process(item)
+def _is_ready(self): return self._ready.is_set()
+
+# Bad: same logic, but now it's 6 lines instead of 3
+if not data:
+    return None
+for item in items:
+    process(item)
+def _is_ready(self):
+    return self._ready.is_set()
+```
+
+When the body is simple, keep it on the same line. Save vertical space for code that actually needs it.
+
+### Names Should Be Short (When Used Often)
+
+This follows "Huffman coding" for variable names—frequently used things get short names:
+
+```python
+# Good: conventional, recognizable
+img, i, msg, ctx
+
+# Bad: verbose for no benefit
+image_data, loop_index, message_object, context_instance
+```
+
+Domain experts recognize `nll` (negative log likelihood) instantly. Spelling it out doesn't help them, and the extra characters push code off the right edge of the screen.
+
+## Installation
+
+```bash
+pip install fastaistyle
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/AnswerDotAI/fastaistyle
+cd fastaistyle
+pip install -e .
+```
+
+## Usage
+
+Check the current directory:
+```bash
+chkstyle
+```
+
+Check a specific path:
+```bash
+chkstyle path/to/code/
+```
+
+The checker prints violations with file paths, line numbers, and the offending code.
+
+## What It Checks
+
+### `dict literal with 3+ identifier keys`
+Use `dict()` for keyword-like keys—it's easier to scan and produces cleaner diffs.
+
+```python
+# Bad
+payload = {"host": host, "port": port, "timeout": timeout}
+
+# Good
+payload = dict(host=host, port=port, timeout=timeout)
+```
+
+### `single-statement body not one-liner`
+If the body is one simple statement, keep it on the header line.
+
+```python
+# Bad
+if ready:
+    return True
+
+# Good
+if ready: return True
+```
+
+### `single-line docstring uses triple quotes`
+Triple quotes are for multi-line strings. Single-line docstrings should use regular quotes.
+
+```python
+# Bad
+def foo():
+    """Return the value."""
+    return x
+
+# Good
+def foo():
+    "Return the value."
+    return x
+```
+
+### `multi-line from-import`
+If it fits on one line, keep it on one line.
+
+```python
+# Bad
+from os import (
+    path,
+    environ,
+)
+
+# Good
+from os import path, environ
+```
+
+### `line >150 chars`
+Wrap at a natural boundary: argument lists, binary operators, or strings. But 150 is generous—aim for ~120 when practical.
+
+### `semicolon statement separator`
+Don't use `;` to combine statements. Use separate lines.
+
+### `inefficient multiline expression`
+If the content would fit in fewer lines, condense it.
+
+```python
+# Bad
+result = call(
+    a,
+    b,
+    c,
+)
+
+# Good
+result = call(a, b, c)
+```
+
+### `lhs assignment annotation`
+Avoid `x: int = 1` in normal code. Put type hints on function parameters and return values instead. The exception is dataclass fields, where annotations are required.
+
+```python
+# Bad
+x: int = 1
+name: str = "hello"
+
+# Good (in a function signature)
+def process(x: int, name: str) -> Result: ...
+```
+
+### `nested generics depth >= 2`
+Keep type annotations simple. Deep nesting makes them hard to read.
+
+```python
+# Bad
+items: list[dict[str, list[int]]]
+
+# Good
+Payload = dict[str, list[int]]
+items: list[Payload]
+```
+
+## Opting Out
+
+Sometimes you have a good reason to format code a specific way. The checker supports pragmas:
+
+```python
+# Ignore a single line
+x: int = 1  # chkstyle: ignore
+
+# Ignore the next line
+# chkstyle: ignore
+y: int = 2
+
+# Disable for a block
+# chkstyle: off
+carefully_formatted = {
+    "alignment": "matters",
+    "here":      "for readability",
+}
+# chkstyle: on
+
+# Skip an entire file (must be in first 5 lines)
+# chkstyle: skip
+```
+
+## Running Tests
+
+```bash
+pytest
+```
+
+## Philosophy
+
+This tool exists to catch mechanical issues, not to enforce taste. The violations it reports are almost always things you'd want to fix—extra vertical space that doesn't help, type annotations that clutter rather than clarify, formatting that makes diffs noisier than necessary.
+
+The goal is code that's pleasant to read and easy to maintain. Dense, but not cramped. Clear, but not verbose. When in doubt, look at the surrounding code and match its style.
+
+For the full style guide, see:
+- [fast.ai Style Guide](https://docs.fast.ai/dev/style.html)
+- [style.md](style.md) in this repo
+
+## License
+
+Apache 2.0

fastaistyle-0.0.5/README.md

@@ -0,0 +1,227 @@
+# fastaistyle
+
+```bash
+pip install fastaistyle
+```
+
+A style checker that enforces the [fast.ai coding style](https://docs.fast.ai/dev/style.html)—a compact, readable approach to Python that keeps more code visible on screen and reduces cognitive load.
+
+## Why This Style?
+
+Most style guides optimize for the wrong thing. They add vertical space, mandate verbose names, and scatter related code across many lines. The result? You see less code at once, which means more scrolling, more context-switching, and more mental effort to understand what's happening.
+
+The fast.ai style takes a different approach, rooted in decades of experience with APL, J, K, and scientific programming. The core insight comes from Kenneth Iverson: **"brevity facilitates reasoning."**
+
+### Your Brain Can Only Hold So Much
+
+When you're reading code, your working memory is limited. If a function spans 50 lines, you can't see the whole thing at once. You scroll down, forget what was at the top, scroll back up. Each scroll is a context switch. Each context switch costs mental energy.
+
+But if that same function fits in 15 lines? You see the whole picture. Your eyes can jump between related parts instantly. Patterns become obvious. Bugs stand out.
+
+This isn't about cramming code together—it's about *removing unnecessary vertical space* so your brain can do what it's good at: recognizing patterns across visible information.
+
+### One Line, One Idea
+
+The goal is density without confusion. Each line should express one complete thought:
+
+```python
+# Good: you see the whole pattern at once
+if not data: return None
+for item in items: process(item)
+def _is_ready(self): return self._ready.is_set()
+
+# Bad: same logic, but now it's 6 lines instead of 3
+if not data:
+    return None
+for item in items:
+    process(item)
+def _is_ready(self):
+    return self._ready.is_set()
+```
+
+When the body is simple, keep it on the same line. Save vertical space for code that actually needs it.
+
+### Names Should Be Short (When Used Often)
+
+This follows "Huffman coding" for variable names—frequently used things get short names:
+
+```python
+# Good: conventional, recognizable
+img, i, msg, ctx
+
+# Bad: verbose for no benefit
+image_data, loop_index, message_object, context_instance
+```
+
+Domain experts recognize `nll` (negative log likelihood) instantly. Spelling it out doesn't help them, and the extra characters push code off the right edge of the screen.
+
+## Installation
+
+```bash
+pip install fastaistyle
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/AnswerDotAI/fastaistyle
+cd fastaistyle
+pip install -e .
+```
+
+## Usage
+
+Check the current directory:
+```bash
+chkstyle
+```
+
+Check a specific path:
+```bash
+chkstyle path/to/code/
+```
+
+The checker prints violations with file paths, line numbers, and the offending code.
+
+## What It Checks
+
+### `dict literal with 3+ identifier keys`
+Use `dict()` for keyword-like keys—it's easier to scan and produces cleaner diffs.
+
+```python
+# Bad
+payload = {"host": host, "port": port, "timeout": timeout}
+
+# Good
+payload = dict(host=host, port=port, timeout=timeout)
+```
+
+### `single-statement body not one-liner`
+If the body is one simple statement, keep it on the header line.
+
+```python
+# Bad
+if ready:
+    return True
+
+# Good
+if ready: return True
+```
+
+### `single-line docstring uses triple quotes`
+Triple quotes are for multi-line strings. Single-line docstrings should use regular quotes.
+
+```python
+# Bad
+def foo():
+    """Return the value."""
+    return x
+
+# Good
+def foo():
+    "Return the value."
+    return x
+```
+
+### `multi-line from-import`
+If it fits on one line, keep it on one line.
+
+```python
+# Bad
+from os import (
+    path,
+    environ,
+)
+
+# Good
+from os import path, environ
+```
+
+### `line >150 chars`
+Wrap at a natural boundary: argument lists, binary operators, or strings. But 150 is generous—aim for ~120 when practical.
+
+### `semicolon statement separator`
+Don't use `;` to combine statements. Use separate lines.
+
+### `inefficient multiline expression`
+If the content would fit in fewer lines, condense it.
+
+```python
+# Bad
+result = call(
+    a,
+    b,
+    c,
+)
+
+# Good
+result = call(a, b, c)
+```
+
+### `lhs assignment annotation`
+Avoid `x: int = 1` in normal code. Put type hints on function parameters and return values instead. The exception is dataclass fields, where annotations are required.
+
+```python
+# Bad
+x: int = 1
+name: str = "hello"
+
+# Good (in a function signature)
+def process(x: int, name: str) -> Result: ...
+```
+
+### `nested generics depth >= 2`
+Keep type annotations simple. Deep nesting makes them hard to read.
+
+```python
+# Bad
+items: list[dict[str, list[int]]]
+
+# Good
+Payload = dict[str, list[int]]
+items: list[Payload]
+```
+
+## Opting Out
+
+Sometimes you have a good reason to format code a specific way. The checker supports pragmas:
+
+```python
+# Ignore a single line
+x: int = 1  # chkstyle: ignore
+
+# Ignore the next line
+# chkstyle: ignore
+y: int = 2
+
+# Disable for a block
+# chkstyle: off
+carefully_formatted = {
+    "alignment": "matters",
+    "here":      "for readability",
+}
+# chkstyle: on
+
+# Skip an entire file (must be in first 5 lines)
+# chkstyle: skip
+```
+
+## Running Tests
+
+```bash
+pytest
+```
+
+## Philosophy
+
+This tool exists to catch mechanical issues, not to enforce taste. The violations it reports are almost always things you'd want to fix—extra vertical space that doesn't help, type annotations that clutter rather than clarify, formatting that makes diffs noisier than necessary.
+
+The goal is code that's pleasant to read and easy to maintain. Dense, but not cramped. Clear, but not verbose. When in doubt, look at the surrounding code and match its style.
+
+For the full style guide, see:
+- [fast.ai Style Guide](https://docs.fast.ai/dev/style.html)
+- [style.md](style.md) in this repo
+
+## License
+
+Apache 2.0

fastaistyle-0.0.5/chkstyle.py

@@ -0,0 +1,297 @@
+#!/usr/bin/env python
+__version__ = "0.0.5"
+
+import ast, io, math, os, re, sys, tokenize
+
+SKIP_DIRS = {".git", ".hg", ".svn", "__pycache__", ".mypy_cache", ".pytest_cache", ".venv", "venv", "dist", "build"}
+WRAP_WIDTH = 120
+COMPOUND_NODES = (ast.If, ast.For, ast.AsyncFor, ast.While, ast.With, ast.AsyncWith, ast.Try, ast.FunctionDef,
+    ast.AsyncFunctionDef, ast.ClassDef)
+
+def iter_py_files(root: str):
+    "Iter py files."
+    for dirpath, dirnames, filenames in os.walk(root, followlinks=False):
+        dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS and not d.startswith(".")]
+        for name in filenames:
+            if not name.endswith(".py"): continue
+            path = os.path.join(dirpath, name)
+            if os.path.islink(path): continue
+            yield path
+
+def is_identifier_str(node) -> bool:
+    "Identifier str."
+    return isinstance(node, ast.Constant) and isinstance(node.value, str) and node.value.isidentifier()
+
+def is_docstring_stmt(stmt) -> bool:
+    "Docstring stmt."
+    return isinstance(stmt, ast.Expr) and isinstance(stmt.value, ast.Constant) and isinstance(stmt.value.value, str)
+
+def node_lines(source: str, lines: list[str], node) -> list[str]:
+    "Node lines."
+    seg = ast.get_source_segment(source, node)
+    if seg: return [line.rstrip() for line in seg.splitlines()]
+    lineno = getattr(node, "lineno", None)
+    if lineno and 1 <= lineno <= len(lines): return [lines[lineno - 1].rstrip("\n")]
+    return []
+
+def segment_lines(source: str, node) -> list[str]:
+    "Segment lines."
+    seg = ast.get_source_segment(source, node)
+    if not seg: return []
+    return [line.rstrip() for line in seg.splitlines()]
+
+def first_line_indent(lines: list[str], lineno: int | None) -> int:
+    "First line indent."
+    if not lineno or lineno < 1 or lineno > len(lines): return 0
+    line = lines[lineno - 1]
+    return len(line) - len(line.lstrip())
+
+def combined_len(seg_lines: list[str], indent: int) -> int:
+    "Combined length."
+    return sum(len(line.strip()) for line in seg_lines) + indent
+
+def is_inefficient_multiline(seg_lines: list[str], indent: int) -> bool:
+    "Inefficient multiline."
+    if len(seg_lines) <= 1: return False
+    total = combined_len(seg_lines, indent)
+    needed = math.ceil(total / WRAP_WIDTH)
+    return needed < len(seg_lines)
+
+def suite_len(lines: list[str], header_lineno: int | None, stmt_lineno: int | None) -> int | None:
+    "Suite length."
+    if not header_lineno or not stmt_lineno: return None
+    if header_lineno < 1 or stmt_lineno < 1: return None
+    if header_lineno > len(lines) or stmt_lineno > len(lines): return None
+    first = lines[header_lineno - 1]
+    second = lines[stmt_lineno - 1]
+    indent = len(first) - len(first.lstrip())
+    return len(first.strip()) + len(second.strip()) + indent
+
+def find_suite_header(lines: list[str], start: int, stop: int, keyword: str) -> int:
+    "Find suite header."
+    if start < 1 or stop < 1 or start > len(lines): return stop
+    stop = max(1, min(stop, len(lines)))
+    for idx in range(start - 1, stop - 2, -1):
+        if lines[idx].lstrip().startswith(f"{keyword}:"): return idx + 1
+    return stop
+
+def add_violation(violations: list[tuple], path: str, lineno: int, msg: str, lines: list[str], suppressed: set[int]):
+    "Add violation."
+    if lineno in suppressed: return
+    violations.append((path, lineno, msg, lines))
+
+def check_single_line_docstring(source: str, lines: list[str], stmt, path: str, violations: list[tuple], suppressed: set[int]):
+    "Check single-line docstring."
+    doc = stmt.value.value
+    if "\n" in doc: return
+    seg = ast.get_source_segment(source, stmt) or ""
+    if re.match(r'^[ \t]*[rRuUbBfF]*\"\"\"', seg):
+        add_violation(violations, path, stmt.lineno, "single-line docstring uses triple quotes",
+            node_lines(source, lines, stmt), suppressed)
+
+def check_suite(parent_kind: str, node, suite, path: str, source: str, lines: list[str], violations: list[tuple],
+    suppressed: set[int]):
+    "Check single-statement suites."
+    if not suite: return
+    if len(suite) != 1: return
+    stmt = suite[0]
+    if is_docstring_stmt(stmt): return
+    if parent_kind == "else" and isinstance(node, ast.If) and isinstance(stmt, ast.If): return
+    if isinstance(stmt, COMPOUND_NODES): return
+    if getattr(stmt, "end_lineno", stmt.lineno) > stmt.lineno: return
+    header_lineno = getattr(node, "lineno", stmt.lineno)
+    if parent_kind in ("else", "finally"): header_lineno = find_suite_header(lines, stmt.lineno, header_lineno, parent_kind)
+    if stmt.lineno <= header_lineno: return
+    total_len = suite_len(lines, header_lineno, stmt.lineno)
+    if total_len is not None and total_len > 130: return
+    header_line = lines[header_lineno - 1].rstrip("\n")
+    body_line = lines[stmt.lineno - 1].rstrip("\n")
+    add_violation(violations, path, header_lineno, f"{parent_kind} single-statement body not one-liner",
+        [header_line] if header_lineno == stmt.lineno else [header_line, body_line], suppressed)
+
+def check_multiline_sig(node, lines: list[str], path: str, violations: list[tuple], suppressed: set[int]):
+    "Check multiline signature/header."
+    if not node.body: return
+    start = node.lineno
+    body_start = node.body[0].lineno
+    if not start or not body_start or body_start <= start + 0: return
+    end = body_start - 1
+    if end <= start: return
+    seg_lines = [lines[i - 1].rstrip("\n") for i in range(start, end + 1)]
+    if isinstance(node, ast.ClassDef) and any(line.lstrip().startswith("@") for line in seg_lines[1:]): return
+    indent = first_line_indent(lines, start)
+    if not is_inefficient_multiline(seg_lines, indent): return
+    add_violation(violations, path, start, "inefficient multiline signature/header", seg_lines, suppressed)
+
+def check_multiline_expr(node, source: str, lines: list[str], path: str, violations: list[tuple], suppressed: set[int]):
+    "Check multiline expression layout."
+    if not node: return
+    if getattr(node, "end_lineno", node.lineno) <= node.lineno: return
+    if isinstance(node, ast.Constant) and isinstance(node.value, str): return
+    if isinstance(node, ast.JoinedStr): return
+    seg_lines = segment_lines(source, node)
+    if not seg_lines or len(seg_lines) <= 1: return
+    indent = first_line_indent(lines, node.lineno)
+    if not is_inefficient_multiline(seg_lines, indent): return
+    add_violation(violations, path, node.lineno, "inefficient multiline expression", seg_lines, suppressed)
+
+def max_subscript_depth(node, depth: int = 0) -> int:
+    "Max subscript depth."
+    if node is None: return depth
+    if isinstance(node, ast.Subscript):
+        depth += 1
+        return max(depth, max_subscript_depth(node.value, depth), max_subscript_depth(node.slice, depth))
+    depths = [max_subscript_depth(child, depth) for child in ast.iter_child_nodes(node)]
+    return max(depths) if depths else depth
+
+def is_dataclass_decorator(dec) -> bool:
+    "Dataclass decorator."
+    if isinstance(dec, ast.Name): return dec.id == "dataclass"
+    if isinstance(dec, ast.Attribute): return dec.attr == "dataclass"
+    if isinstance(dec, ast.Call): return is_dataclass_decorator(dec.func)
+    return False
+
+def dataclass_annassigns(tree) -> set:
+    "Dataclass annassigns."
+    annassigns = set()
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.ClassDef): continue
+        if not any(is_dataclass_decorator(dec) for dec in node.decorator_list): continue
+        for stmt in node.body:
+            if isinstance(stmt, ast.AnnAssign): annassigns.add(stmt)
+    return annassigns
+
+def check_annotation(node, source: str, lines: list[str], path: str, violations: list[tuple], suppressed: set[int]):
+    "Check annotation depth and layout."
+    if node is None: return
+    if getattr(node, "end_lineno", node.lineno) > node.lineno:
+        seg_lines = segment_lines(source, node)
+        indent = first_line_indent(lines, node.lineno)
+        if is_inefficient_multiline(seg_lines, indent):
+            add_violation(violations, path, node.lineno, "inefficient multiline annotation", seg_lines, suppressed)
+    depth = max_subscript_depth(node)
+    if depth >= 2:
+        add_violation(violations, path, getattr(node, "lineno", 1), f"nested generics depth {depth}",
+            node_lines(source, lines, node), suppressed)
+
+def should_skip_file(lines: list[str]) -> bool:
+    "Skip file."
+    head = lines[:5]
+    return any("chkstyle: skip" in line for line in head)
+
+def suppressed_lines(lines: list[str]) -> set[int]:
+    "Suppressed lines."
+    suppressed = set()
+    off = False
+    ignore_next = False
+    for lineno, line in enumerate(lines, start=1):
+        stripped = line.strip()
+        if "chkstyle: on" in line:
+            off = False
+            ignore_next = False
+            continue
+        if "chkstyle: off" in line:
+            off = True
+            ignore_next = False
+            suppressed.add(lineno)
+            continue
+        if off: suppressed.add(lineno)
+        if "chkstyle: ignore" in line:
+            if stripped.startswith("#"): ignore_next = True
+            else: suppressed.add(lineno)
+        elif ignore_next and stripped and not stripped.startswith("#"):
+            suppressed.add(lineno)
+            ignore_next = False
+    return suppressed
+
+def check_file(path: str) -> list[tuple]:
+    "Check file."
+    with open(path, encoding="utf-8") as f: source = f.read()
+    lines = source.splitlines()
+    if should_skip_file(lines): return []
+    try: tree = ast.parse(source, filename=path)
+    except SyntaxError as e: return [(path, e.lineno or 1, f"syntax error: {e.msg}", [])]
+    violations = []
+    suppressed = suppressed_lines(lines)
+    for lineno, line in enumerate(lines, start=1):
+        if len(line) > 150: add_violation(violations, path, lineno, "line >150 chars", [line], suppressed)
+    try:
+        for tok in tokenize.generate_tokens(io.StringIO(source).readline):
+            if tok.type == tokenize.OP and tok.string == ";":
+                lineno = tok.start[0]
+                add_violation(violations, path, lineno, "semicolon statement separator", [lines[lineno - 1]], suppressed)
+    except tokenize.TokenError: pass
+    if tree.body and is_docstring_stmt(tree.body[0]):
+        check_single_line_docstring(source, lines, tree.body[0], path, violations, suppressed)
+    dataclass_fields = dataclass_annassigns(tree)
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Dict) and len(node.keys) >= 3 and all(is_identifier_str(k) for k in node.keys):
+            add_violation(violations, path, node.lineno, "dict literal with 3+ identifier keys",
+                node_lines(source, lines, node), suppressed)
+        if isinstance(node, ast.AnnAssign):
+            if node not in dataclass_fields:
+                add_violation(violations, path, node.lineno, "lhs assignment annotation", node_lines(source, lines, node), suppressed)
+            check_multiline_expr(node.value, source, lines, path, violations, suppressed)
+            check_annotation(node.annotation, source, lines, path, violations, suppressed)
+        if isinstance(node, ast.ImportFrom):
+            seg = ast.get_source_segment(source, node) or ""
+            if "\n" in seg:
+                import_lines = node_lines(source, lines, node)
+                total_len = sum(len(line.strip()) for line in import_lines)
+                if total_len <= 150:
+                    add_violation(violations, path, node.lineno, "multi-line from-import", import_lines, suppressed)
+        has_doc = isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)) and node.body
+        if has_doc and is_docstring_stmt(node.body[0]):
+            check_single_line_docstring(source, lines, node.body[0], path, violations, suppressed)
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            check_multiline_sig(node, lines, path, violations, suppressed)
+            if node.returns: check_annotation(node.returns, source, lines, path, violations, suppressed)
+            for arg in node.args.args + node.args.kwonlyargs:
+                if arg.annotation: check_annotation(arg.annotation, source, lines, path, violations, suppressed)
+            if node.args.vararg and node.args.vararg.annotation:
+                check_annotation(node.args.vararg.annotation, source, lines, path, violations, suppressed)
+            if node.args.kwarg and node.args.kwarg.annotation:
+                check_annotation(node.args.kwarg.annotation, source, lines, path, violations, suppressed)
+            if node.args.posonlyargs:
+                for arg in node.args.posonlyargs:
+                    if arg.annotation: check_annotation(arg.annotation, source, lines, path, violations, suppressed)
+        if isinstance(node, ast.ClassDef): check_multiline_sig(node, lines, path, violations, suppressed)
+        if isinstance(node, ast.Assign): check_multiline_expr(node.value, source, lines, path, violations, suppressed)
+        if isinstance(node, ast.AugAssign): check_multiline_expr(node.value, source, lines, path, violations, suppressed)
+        if isinstance(node, ast.Return): check_multiline_expr(node.value, source, lines, path, violations, suppressed)
+        if isinstance(node, ast.Expr) and not is_docstring_stmt(node):
+            check_multiline_expr(node.value, source, lines, path, violations, suppressed)
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            check_suite("def", node, node.body, path, source, lines, violations, suppressed)
+        elif isinstance(node, ast.If):
+            check_suite("if", node, node.body, path, source, lines, violations, suppressed)
+            check_suite("else", node, node.orelse, path, source, lines, violations, suppressed)
+        elif isinstance(node, (ast.For, ast.AsyncFor)):
+            check_suite("for", node, node.body, path, source, lines, violations, suppressed)
+            check_suite("else", node, node.orelse, path, source, lines, violations, suppressed)
+        elif isinstance(node, ast.While):
+            check_suite("while", node, node.body, path, source, lines, violations, suppressed)
+            check_suite("else", node, node.orelse, path, source, lines, violations, suppressed)
+        elif isinstance(node, (ast.With, ast.AsyncWith)): check_suite("with", node, node.body, path, source, lines, violations, suppressed)
+        elif isinstance(node, ast.Try):
+            check_suite("try", node, node.body, path, source, lines, violations, suppressed)
+            for handler in node.handlers: check_suite("except", handler, handler.body, path, source, lines, violations, suppressed)
+            check_suite("else", node, node.orelse, path, source, lines, violations, suppressed)
+            check_suite("finally", node, node.finalbody, path, source, lines, violations, suppressed)
+    return violations
+
+def main(argv: list[str]) -> int:
+    "Main."
+    root = argv[1] if len(argv) > 1 else "."
+    all_violations = []
+    for path in iter_py_files(root): all_violations.extend(check_file(path))
+    for path, lineno, msg, lines in sorted(all_violations,
+        key=lambda item: (item[0], item[1], item[2])):
+        print(f"# {path}:{lineno}: {msg}")
+        for line in lines: print(line)
+    print(f"found {len(all_violations)} potential violation(s)")
+    return 1 if all_violations else 0
+
+def cli(): raise SystemExit(main(sys.argv))
+
+if __name__ == "__main__": cli()

fastaistyle-0.0.5/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fastaistyle"
+dynamic = ["version"]
+description = "Style checker for fast.ai coding conventions"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.10"
+authors = [{name = "Jeremy Howard", email = "j@fast.ai"}]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[project.scripts]
+chkstyle = "chkstyle:cli"
+
+[project.urls]
+Homepage = "https://github.com/AnswerDotAI/fastaistyle"
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]
+only-include = ["chkstyle.py"]
+
+[tool.hatch.version]
+path = "chkstyle.py"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

fastaistyle-0.0.5/style.md

@@ -0,0 +1,53 @@
+# Repo Style
+
+Keep the code compact, readable, and consistent with the surrounding file. Prefer clarity over strict formatting rules. Do not follow PEP-8.
+
+## Layout
+- Aim to avoid >140 chars on a line.  
+- Keep one logical idea per line.  
+- Never use `;` to combine multiple statements on a line
+- Avoid inefficient multi-line expressions/signatures: if the combined stripped length would fit in fewer ~120-char lines, keep it tighter.
+- Single-line bodies are preferred for short `with`, `open`, `try`, `except`, `catch`, `for`, and `if` statements, plus small one-line functions.  
+  - Good: `if not data: return None`  
+  - Bad: `if not data:\n    return None`  
+- Single-line bodies are preferred for small one-line functions that don't need a docstring (i.e because they're private or a dunder function).  
+  - Good: `def _is_ready(self): return self._ready.is_set()`  
+  - Bad: `def _is_ready(self):\n    return self._ready.is_set()`  
+- Be frugal with vertical whitespace.
+- Avoid nearly all comments, unless really required to explain an otherwise-obscure issue.  
+- Indent with 4 spaces; avoid trailing whitespace.  
+- Avoid auto-formatters that rewrite layout.  
+- Group imports; multiple modules on one line is preferred.  
+  - Good: `import json, os, time`  
+  - Bad: `import json\nimport os\nimport time`  
+  - Good: `from mymod import (\n    a,\n    b\n)`
+  - Bad: `from mymod import a,b`
+
+## Naming
+- Use standard Python casing.  
+- Prefer short, conventional names for frequently used values; follow existing abbreviations.  
+  - Good: `msg_id`, `iopub`, `ctx`, `i`
+  - Bad: `message_identifier`, `io_pub_channel`, `context_object`, `loop_index`
+
+## Structure
+- Favor small helpers over repetitive blocks.  
+  - Good: `def _send_stream(self, name, text): ...; self._send_stream("stdout", out)`  
+  - Bad: `self._send(sock, "stream", {"name": "stdout", "text": out}, parent)`  
+- Use comprehensions or inline expressions when they improve clarity.  
+  - Good: `ids = [m["header"]["msg_id"] for m in msgs]`  
+  - Bad: `ids = []\nfor m in msgs: ids.append(m["header"]["msg_id"])`  
+
+## Typing
+- Never add type annotations to LHS assignments (e.g. `x: int = 1`), except dataclass fields.  
+- Keep annotations simple; avoid nested generics beyond one level unless you have a strong reason.  
+
+## Documentation
+- Use brief single-line docstrings for multi-line functions.  
+  - Good: `def run(self):\n    "Run the thread."\n    ...`  
+  - Bad: `def run(self):\n    \"\"\"\n    Run the thread.\n    \"\"\"\n    ...`  
+- Add comments only when they explain why. That means add VERY few comments!
+  - Good: `self._stop_event.set()  # ensures poll loop exits before socket close`  
+  - Bad: `self._stop_event.set()  # stop the event`  
+
+## Testing
+- All tests must pass before changes are considered complete.  

fastaistyle-0.0.5/tests/test_chkstyle.py

@@ -0,0 +1,92 @@
+# chkstyle: skip
+import textwrap
+
+import chkstyle
+
+def _write(tmp_path, name: str, content: str):
+    path = tmp_path / name
+    path.write_text(textwrap.dedent(content).lstrip(), encoding="utf-8")
+    return path
+
+def _messages(violations):
+    return {msg for _path, _lineno, msg, _lines in violations}
+
+def test_chkstyle_reports_expected_violations(tmp_path):
+    path = _write(
+        tmp_path,
+        "cases.py",
+        '''
+        def f():
+            """doc"""
+            return 1
+
+        x: int = 1
+        data = {"a": 1, "b": 2, "c": 3}
+        a = 1; b = 2
+        from os import (
+            path,
+            environ,
+        )
+        if True:
+            y = 1
+        z = dict(
+            a=1,
+            b=2,
+        )
+        long = "......................................................................................................................................................."
+        def g(x: list[list[int]]): return x
+        ''',
+    )
+    msgs = _messages(chkstyle.check_file(str(path)))
+    expected = {
+        "single-line docstring uses triple quotes",
+        "lhs assignment annotation",
+        "dict literal with 3+ identifier keys",
+        "semicolon statement separator",
+        "multi-line from-import",
+        "if single-statement body not one-liner",
+        "inefficient multiline expression",
+        "line >150 chars",
+        "nested generics depth 2",
+    }
+    assert expected.issubset(msgs)
+
+def test_chkstyle_ignore_and_off_on(tmp_path):
+    path = _write(
+        tmp_path,
+        "ignore.py",
+        """
+        x: int = 1  # chkstyle: ignore
+        # chkstyle: ignore
+        y: int = 2
+        # chkstyle: off
+        z: int = 3
+        # chkstyle: on
+        """,
+    )
+    assert chkstyle.check_file(str(path)) == []
+
+def test_chkstyle_skip_file(tmp_path):
+    path = _write(
+        tmp_path,
+        "skip.py",
+        """
+        # chkstyle: skip
+        x: int = 1
+        data = {"a": 1, "b": 2, "c": 3}
+        """,
+    )
+    assert chkstyle.check_file(str(path)) == []
+
+def test_chkstyle_allows_multiline_strings(tmp_path):
+    path = _write(
+        tmp_path,
+        "strings.py",
+        '''
+        value = """
+        line one
+        line two
+        """
+        ''',
+    )
+    assert chkstyle.check_file(str(path)) == []

fastaistyle-0.0.5/tools/release.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+set -e
+
+bump=${1:-patch}
+version=$(hatch version)
+
+git add -A
+git commit -m "v$version" || true  # ok if nothing to commit
+git tag "v$version"
+git push
+git push --tags
+
+echo "Released v$version"
+
+hatch version $bump
+git add -A
+git commit -m "bump to $(hatch version)"
+git push
+
+echo "Dev now at $(hatch version)"