codecrate 0.1.0__py3-none-any.whl

codecrate/unpacker.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import hashlib
+import re
+import warnings
+from pathlib import Path
+
+from .mdparse import parse_packed_markdown
+from .udiff import ensure_parent_dir
+
+_MARK_RE = re.compile(r"FUNC:([0-9A-Fa-f]{8})")
+
+
+def _ws_len(s: str) -> int:
+    return len(s) - len(s.lstrip(" \t"))
+
+
+def _apply_canonical_into_stub(
+    stub: str, defs: list[dict], canonical: dict[str, str]
+) -> str:
+    """
+    Reconstruct original by locating FUNC:<id> markers in the stub and replacing the
+    surrounding def region (decorators + def + stubbed body/docstring) with the
+    canonical code. Does not rely on line-number alignment.
+
+    Marker semantics:
+    - New packs use local_id in stub markers (unique per occurrence).
+    - Canonical code is still fetched by id (deduped across identical bodies).
+    - For backwards compatibility, we also accept markers keyed by id.
+    """
+    lines = stub.splitlines(keepends=True)
+
+    # Allow multiple occurrences of the same marker id (older dedupe packs).
+    marker_lines_for: dict[str, list[int]] = {}
+    for i, ln in enumerate(lines):
+        m = _MARK_RE.search(ln)
+        if m:
+            marker_lines_for.setdefault(m.group(1).upper(), []).append(i)
+
+    # Apply bottom-up so indices remain stable.
+    work: list[tuple[int, dict, str]] = []
+    for d in defs:
+        cid = d.get("id") or d.get("local_id")
+        if not cid:
+            continue
+
+        # Prefer locating the marker by local_id (unique), but fall back to cid for
+        # older packs.
+        marker_key = d.get("local_id") or cid
+        idxs = marker_lines_for.get(str(marker_key).upper())
+        if not idxs and str(cid).upper() != str(marker_key).upper():
+            idxs = marker_lines_for.get(str(cid).upper())
+
+        if not idxs:
+            continue
+
+        mi = idxs.pop()  # consume the bottom-most occurrence
+        work.append((mi, d, str(cid)))
+
+    work.sort(key=lambda t: t[0], reverse=True)
+
+    for mi, d, cid in work:
+        # Fetch canonical by cid first, then fall back to local_id.
+        code = canonical.get(cid)
+        if code is None:
+            alt = d.get("local_id")
+            if alt:
+                code = canonical.get(str(alt))
+        if code is None:
+            continue
+
+        # Find def line above (supports single-line defs where marker is on def line).
+        def_i = mi
+        while def_i >= 0:
+            s = lines[def_i].lstrip(" \t")
+            if s.startswith("def ") or s.startswith("async def "):
+                break
+            def_i -= 1
+        if def_i < 0:
+            continue
+
+        def_indent = _ws_len(lines[def_i])
+
+        # Include decorators directly above the def.
+        start_i = def_i
+        j = def_i - 1
+        while j >= 0:
+            if _ws_len(lines[j]) == def_indent and lines[j].lstrip(" \t").startswith(
+                "@"
+            ):
+                start_i = j
+                j -= 1
+                continue
+            break
+
+        # Replace through the marker line (or just the def line for single-line defs).
+        end_i = (def_i + 1) if mi == def_i else (mi + 1)
+
+        repl = code.splitlines(keepends=True)
+        if repl and not repl[-1].endswith("\n"):
+            repl[-1] = repl[-1] + "\n"
+        lines[start_i:end_i] = repl
+
+    return "".join(lines)
+
+
+def unpack_to_dir(markdown_text: str, out_dir: Path) -> None:
+    packed = parse_packed_markdown(markdown_text)
+    manifest = packed.manifest
+    if manifest.get("format") != "codecrate.v4":
+        raise ValueError(f"Unsupported format: {manifest.get('format')}")
+
+    out_dir = out_dir.resolve()
+    missing: list[str] = []
+    for f in manifest.get("files", []):
+        rel = f["path"]
+        stub = packed.stubbed_files.get(rel)
+        exp = f.get("line_count")
+        exp_n = int(exp) if exp is not None else None
+        if stub is None or (exp_n and exp_n > 0 and not stub.strip()):
+            missing.append(rel)
+            continue
+
+        defs = f.get("defs", [])
+        reconstructed = _apply_canonical_into_stub(stub, defs, packed.canonical_sources)
+
+        exp_sha = f.get("sha256_original")
+        if exp_sha:
+            got_sha = hashlib.sha256(reconstructed.encode("utf-8")).hexdigest()
+            if got_sha != exp_sha:
+                warnings.warn(
+                    f"SHA256 mismatch for {rel}: expected {exp_sha}, got {got_sha}",
+                    RuntimeWarning,
+                    stacklevel=2,
+                )
+
+        # Prevent path traversal / writing outside out_dir
+        target = (out_dir / rel).resolve()
+        if out_dir != target and out_dir not in target.parents:
+            raise ValueError(f"Refusing to write outside out_dir: {rel}")
+        ensure_parent_dir(target)
+        target.write_text(reconstructed, encoding="utf-8")
+
+    if missing:
+        files_str = ", ".join(missing[:10])
+        if len(missing) > 10:
+            files_str += "..."
+        msg = f"Missing stubbed file blocks for {len(missing)} file(s): {files_str}"
+        warnings.warn(msg, RuntimeWarning, stacklevel=2)

codecrate/validate.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import hashlib
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from .mdparse import parse_packed_markdown
+from .udiff import normalize_newlines
+from .unpacker import _apply_canonical_into_stub
+
+_MARK_RE = re.compile(r"FUNC:([0-9A-Fa-f]{8})")
+
+
+def _sha256_text(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+@dataclass(frozen=True)
+class ValidationReport:
+    errors: list[str]
+    warnings: list[str]
+
+
+def validate_pack_markdown(
+    markdown_text: str, *, root: Path | None = None
+) -> ValidationReport:
+    """Validate a packed Codecrate Markdown for internal consistency.
+
+    Checks (pack-only):
+    - Every manifest file has a corresponding stubbed code block.
+    - sha256_stubbed matches the stubbed code block (normalized newlines).
+    - Every def in manifest has a canonical body in the function library.
+    - Reconstructing each file from stub+canonical reproduces sha256_original.
+    - Marker collisions / missing markers are reported as warnings.
+
+    Optional root:
+    - If provided, compares reconstructed 'original' text against files on disk.
+    """
+    packed = parse_packed_markdown(markdown_text)
+    manifest = packed.manifest
+
+    errors: list[str] = []
+    warnings: list[str] = []
+
+    root_resolved = root.resolve() if root is not None else None
+
+    files = manifest.get("files") or []
+    for f in files:
+        rel = f.get("path")
+        if not rel:
+            errors.append("Manifest entry missing 'path'")
+            continue
+
+        stub = packed.stubbed_files.get(rel)
+        if stub is None:
+            errors.append(f"Missing stubbed file block for {rel}")
+            continue
+
+        stub_norm = normalize_newlines(stub)
+        exp_stub = f.get("sha256_stubbed")
+        got_stub = _sha256_text(stub_norm)
+        if exp_stub and got_stub != exp_stub:
+            errors.append(
+                f"Stub sha mismatch for {rel}: expected {exp_stub}, got {got_stub}"
+            )
+
+        marker_ids = [m.group(1).upper() for m in _MARK_RE.finditer(stub_norm)]
+        if marker_ids:
+            from collections import Counter
+
+            c = Counter(marker_ids)
+            dup = [k for k, v in c.items() if v > 1]
+            if dup:
+                warnings.append(f"Marker collision in {rel}: {', '.join(sorted(dup))}")
+
+        defs = f.get("defs") or []
+        for d in defs:
+            cid = str(d.get("id") or "").upper()
+            lid = str(d.get("local_id") or "").upper()
+            if cid and cid not in packed.canonical_sources:
+                errors.append(
+                    f"Missing canonical source for {rel}:{d.get('qualname')} id={cid}"
+                )
+
+            # local_id marker is preferred; fall back to id for older packs
+            if (lid and lid not in marker_ids) and (cid and cid not in marker_ids):
+                warnings.append(
+                    f"Missing FUNC marker in stub for {rel}:{d.get('qualname')} "
+                    f"(local_id={lid or '∅'}, id={cid or '∅'})"
+                )
+
+        try:
+            reconstructed = _apply_canonical_into_stub(
+                stub_norm, defs, packed.canonical_sources
+            )
+            reconstructed = normalize_newlines(reconstructed)
+        except Exception as e:  # pragma: no cover
+            errors.append(f"Failed to reconstruct {rel}: {e}")
+            continue
+
+        exp_orig = f.get("sha256_original")
+        got_orig = _sha256_text(reconstructed)
+        if exp_orig and got_orig != exp_orig:
+            errors.append(
+                f"Original sha mismatch for {rel}: expected {exp_orig}, got {got_orig}"
+            )
+
+        if root_resolved is not None:
+            disk_path = root_resolved / rel
+            if not disk_path.exists():
+                warnings.append(f"On-disk file missing under root: {rel}")
+            else:
+                disk_text = normalize_newlines(
+                    disk_path.read_text(encoding="utf-8", errors="replace")
+                )
+                if _sha256_text(disk_text) != got_orig:
+                    warnings.append(f"On-disk file differs from pack for {rel}")
+
+    return ValidationReport(errors=errors, warnings=warnings)

codecrate-0.1.0.dist-info/METADATA

@@ -0,0 +1,357 @@
+Metadata-Version: 2.4
+Name: codecrate
+Version: 0.1.0
+Summary: Pack Python codebases into Markdown optimized for LLM context delivery (pack/unpack/patch/apply)
+Author-email: Holger Nahrstaedt <nahrstaedt@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Holger Nahrstaedt
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/holgern/codecrate
+Keywords: code,llm,markdown
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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: Topic :: Software Development :: Libraries
+Requires-Python: >3.9.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pathspec
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: ruff>=0.5.0; extra == "dev"
+Dynamic: license-file
+
+[![PyPI - Version](https://img.shields.io/pypi/v/codecrate)](https://pypi.org/project/codecrate/)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/codecrate)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/codecrate)
+[![codecov](https://codecov.io/gh/holgern/codecrate/graph/badge.svg?token=iCHXwbjAXG)](https://codecov.io/gh/holgern/codecrate)
+
+# codecrate
+
+`codecrate` turns a Python repository into a Markdown "context pack" optimized for LLM consumption, with full round-trip support:
+
+- `pack`: repo → context.md
+- `unpack`: context.md → reconstructed files
+- `patch`: old context.md + current repo → diff-only patch.md
+- `apply`: patch.md → apply changes to repo
+
+## Features
+
+- **Markdown-native output**: Generates self-contained Markdown files with syntax highlighting
+- **Symbol index**: Quick navigation to functions and classes
+- **Deduplication**: Optionally deduplicate identical function bodies to save tokens
+- **Two layout modes**:
+  - `stubs`: Compact file stubs with function bodies in a separate "Function Library"
+  - `full`: Complete file contents (no stubbing)
+- **Round-trip support**: Reconstruct original files exactly from Markdown packs
+- **Diff generation**: Create minimal patch Markdown files showing only changed code
+- **Gitignore support**: Respect `.gitignore` when scanning files
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+Or for development:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Quick Start
+
+### Pack a Repository
+
+Pack your current directory into `context.md`:
+
+```bash
+codecrate pack .
+```
+
+Pack with specific output file:
+
+```bash
+codecrate pack . -o my_project.md
+```
+
+### Unpack to Reconstruct Files
+
+Reconstruct files from a packed Markdown:
+
+```bash
+codecrate unpack context.md -o reconstructed/
+```
+
+### Generate and Apply Patches
+
+1. Pack your repository as a baseline:
+
+```bash
+codecrate pack . -o baseline.md
+```
+
+2. Make changes to your code
+
+3. Generate a patch:
+
+```bash
+codecrate patch baseline.md . -o changes.md
+```
+
+4. Apply the patch:
+
+```bash
+codecrate apply changes.md .
+```
+
+## Configuration
+
+Create a `codecrate.toml` file in your repository root:
+
+```toml
+[codecrate]
+# File patterns to include (default: ["**/*.py"])
+include = ["**/*.py"]
+
+# File patterns to exclude
+exclude = ["**/test_*.py", "**/tests/**"]
+
+# Deduplicate identical function bodies (default: false)
+dedupe = true
+
+# Keep docstrings in stubbed file view (default: true)
+keep_docstrings = true
+
+# Respect .gitignore when scanning (default: true)
+respect_gitignore = true
+
+# Output layout: "auto", "stubs", or "full" (default: "auto")
+# - auto: use stubs only if dedupe collapses something
+# - stubs: always use stubs + Function Library
+# - full: emit complete file contents
+layout = "auto"
+
+# Split output into multiple files if char count exceeds this (0 = no split)
+split_max_chars = 0
+```
+
+## Command Reference
+
+### `pack` - Pack Repository to Markdown
+
+```bash
+codecrate pack <root> [OPTIONS]
+```
+
+**Options:**
+
+- `-o, --output PATH`: Output markdown path (default: `context.md`)
+- `--dedupe`: Deduplicate identical function bodies
+- `--layout {auto,stubs,full}`: Output layout mode
+- `--keep-docstrings` / `--no-keep-docstrings`: Keep docstrings in stubs
+- `--respect-gitignore` / `--no-respect-gitignore`: Respect `.gitignore`
+- `--include GLOB`: Include glob pattern (repeatable)
+- `--exclude GLOB`: Exclude glob pattern (repeatable)
+- `--split-max-chars N`: Split output into `.partN.md` files
+
+### `unpack` - Reconstruct Files from Markdown
+
+```bash
+codecrate unpack <markdown> -o <out-dir>
+```
+
+**Options:**
+
+- `-o, --out-dir PATH`: Output directory for reconstructed files (required)
+
+### `patch` - Generate Diff-Only Patch
+
+```bash
+codecrate patch <old_markdown> <root> [OPTIONS]
+```
+
+**Options:**
+
+- `-o, --output PATH`: Output patch markdown (default: `patch.md`)
+
+### `apply` - Apply Patch to Repository
+
+```bash
+codecrate apply <patch_markdown> <root>
+```
+
+### `validate-pack` - Validate Pack
+
+```bash
+codecrate validate-pack <markdown> [--root PATH]
+```
+
+**Options:**
+
+- `--root PATH`: Optional repo root to compare reconstructed files against
+
+## Layout Modes
+
+### Stubs Mode (Default for `auto` when dedupe is effective)
+
+Creates compact file stubs with function bodies replaced by markers:
+
+```python
+def f(x):
+    ...  # ↪ FUNC:0F203CE2
+
+class C:
+    def m(self):
+        ...  # ↪ FUNC:6F8ECF73
+```
+
+Function bodies are stored in a separate "Function Library" section:
+
+````markdown
+## Function Library
+
+### 0F203CE2 — `a.f` (a.py:L1–L2)
+
+```python
+def f(x):
+    return x + 1
+```
+````
+
+### 6F8ECF73 — `a.C.m` (a.py:L5–L6)
+
+```python
+    def m(self):
+        return 42
+```
+
+````
+
+This is ideal for:
+- LLMs with limited context windows
+- Repositories with duplicate code (when using `--dedupe`)
+- Code review and analysis workflows
+
+### Full Mode
+
+Emits complete file contents without stubbing:
+
+```python
+def f(x):
+    return x + 1
+
+class C:
+    def m(self):
+        return 42
+````
+
+This is ideal for:
+
+- Repositories without much duplicate code
+- When you need complete context in one place
+- When token limits are not a concern
+
+## Workflow Example
+
+### Initial Pack
+
+```bash
+# Create a baseline pack of your repository
+codecrate pack . -o baseline.md
+
+# Send baseline.md to an LLM for analysis
+# LLM can navigate using the Symbol Index
+# and read full code in the Files section
+```
+
+### Iterate with LLM
+
+```bash
+# After the LLM suggests changes, generate a patch
+codecrate patch baseline.md . -o iteration1.md
+
+# Send iteration1.md to the LLM (much smaller than full pack)
+# Apply the LLM's changes
+codecrate apply iteration1.md .
+
+# Create new baseline for next iteration
+codecrate pack . -o baseline.md
+```
+
+## Advanced Usage
+
+### Packing Multiple Projects
+
+```bash
+# Pack different directories separately
+codecrate pack src/backend -o backend.md
+codecrate pack src/frontend -o frontend.md
+
+# Or pack with specific include patterns
+codecrate pack . --include "**/*.py" --exclude "**/migrations/**"
+```
+
+### Handling Large Contexts
+
+```bash
+# Split into multiple files to fit context windows
+codecrate pack . --split-max-chars 50000
+
+# This creates context.md, context.part1.md, context.part2.md, etc.
+```
+
+### Deduplication
+
+```bash
+# Enable deduplication to save tokens on duplicate code
+codecrate pack . --dedupe
+
+# Deduplication is most effective when you have:
+# - Copy-pasted functions
+# - Boilerplate code
+# - Similar utility functions across modules
+```
+
+## How It Works
+
+1. **Discovery**: Scans files according to include/exclude patterns
+2. **Parsing**: Extracts symbol information (functions, classes) using Python's AST
+3. **Packing**: Creates a structured manifest and canonical function definitions
+4. **Rendering**: Generates Markdown with directory tree, symbol index, and file contents
+5. **Validation**: Ensures round-trip consistency with SHA256 checksums
+
+The Markdown format is designed to be:
+
+- **Self-contained**: All necessary information in one file
+- **Navigable**: Symbol index with jump links
+- **Reversible**: Can reconstruct original files exactly
+- **Diff-friendly**: Easy to generate minimal patches
+
+## License
+
+MIT

codecrate-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+codecrate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codecrate/_version.py,sha256=5jwwVncvCiTnhOedfkzzxmxsggwmTBORdFL_4wq0ZeY,704
+codecrate/cli.py,sha256=4dH2IYVTXQ33GHpomnViKbrlVGdcJUK_3h263nCWOtc,8294
+codecrate/config.py,sha256=EuOMR0rSq2T5ZuorjfIYrhsX3j1taAsZ_3AsYPGakYQ,3147
+codecrate/diffgen.py,sha256=xMH-wJeMox_xoMLrGck2o7RP5mjlCJjndSHPHql9CJg,3432
+codecrate/discover.py,sha256=eWebPPbPHy5WrtbCX-RA1hKiPyQau6buUm5OcjpVi9U,2847
+codecrate/ids.py,sha256=fO_PAaskT7hLXgvJN7Hv4HD27zPIFnSziB0k2AUpONo,517
+codecrate/manifest.py,sha256=z7fHqZS5vHanMSla-_083e_A9KXuYnWccZyu-wQNl2s,1074
+codecrate/markdown.py,sha256=2ruEmsCF9v-aPpiKEOGusi4T13wEzugNn7JSN6T7KGg,16670
+codecrate/mdparse.py,sha256=Lu9aN3rMP5qetwLapVrRvVRohPXv8L0hmjG0GUG7jys,4746
+codecrate/model.py,sha256=Px9xL4odcvlDgEnSiwd5SMi9_k1Xck4R8DOlahN9Z-4,897
+codecrate/packer.py,sha256=an-E1ZilIOY2hdjF4Gt3J5APOCTRRpiinmvfBiw29Ds,3398
+codecrate/parse.py,sha256=Huu2PjHPBE1cCYI_GsYhgOqXoifP076asg5Tlsfpf8E,4437
+codecrate/stubber.py,sha256=9WxpQs6FTCT0OUX4Si8GdD63VyUJQnNqRcwTm_IPuKc,2857
+codecrate/token_budget.py,sha256=0vG9h7l5yNn909QQEItrYQJIjMT2h5LcM9iZf4zu-3c,12937
+codecrate/udiff.py,sha256=bMvwhgqXZw2pIW5VcRRATUoDspM2XGQU3nInD_A7WWo,6249
+codecrate/unpacker.py,sha256=soh6qwRE6sxoBAbr3UbXk1O5aiwdnfUhkqfFdSvU0_I,5063
+codecrate/validate.py,sha256=-KVU7RQ8zJG-YJoD8kLCYgE0OWWdy-yYzl0gyp-3mWo,4250
+codecrate-0.1.0.dist-info/licenses/LICENSE,sha256=O6yVC2oL8vUoAA3oPEvLSbvxzmwtOOPiY7dOZzgrxi0,1074
+codecrate-0.1.0.dist-info/METADATA,sha256=fwuc8JDMxUx1h9JRTr5vd0JgJ34uZxk7CkEfZqEAR-M,9394
+codecrate-0.1.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+codecrate-0.1.0.dist-info/entry_points.txt,sha256=DcY9tib-PzdLebck4B2RYJ0CGH6cqAJMCHPU3MdA0Dk,49
+codecrate-0.1.0.dist-info/top_level.txt,sha256=-jD2a_aH1iQN4atRhGw7ZhEYnOWe88nfmkz6sPZ6WEg,10
+codecrate-0.1.0.dist-info/RECORD,,

codecrate-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

codecrate-0.1.0.dist-info/entry_points.txt

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

codecrate-0.1.0.dist-info/licenses/LICENSE

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

codecrate-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+codecrate