Upload 257 files

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10
+
+RUN useradd -m -u 1000 user && python -m pip install --upgrade pip
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+ENV MCP_TRANSPORT=http
+ENV MCP_PORT=7860
+
+EXPOSE 7860
+
+CMD ["python", "whoosh/mcp_output/start_mcp.py"]

README.md

@@ -1,10 +1,32 @@
 ---
-title: Whoosh
-emoji: 🏆
-colorFrom: yellow
-colorTo: pink
+title: Whoosh MCP
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
 sdk: docker
+sdk_version: "4.26.0"
+app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Whoosh MCP Service
+
+Auto-generated MCP service for whoosh.
+
+## Usage
+
+```
+https://None-whoosh-mcp.hf.space/mcp
+```
+
+## Connect with Cursor
+
+```json
+{
+  "mcpServers": {
+    "whoosh": {
+      "url": "https://None-whoosh-mcp.hf.space/mcp"
+    }
+  }
+}
+```

app.py

@@ -0,0 +1,45 @@
+from fastapi import FastAPI
+import os
+import sys
+
+mcp_plugin_path = os.path.join(os.path.dirname(__file__), "whoosh", "mcp_output", "mcp_plugin")
+sys.path.insert(0, mcp_plugin_path)
+
+app = FastAPI(
+    title="Whoosh MCP Service",
+    description="Auto-generated MCP service for whoosh",
+    version="1.0.0"
+)
+
+@app.get("/")
+def root():
+    return {
+        "service": "Whoosh MCP Service",
+        "version": "1.0.0",
+        "status": "running",
+        "transport": os.environ.get("MCP_TRANSPORT", "http")
+    }
+
+@app.get("/health")
+def health_check():
+    return {"status": "healthy", "service": "whoosh MCP"}
+
+@app.get("/tools")
+def list_tools():
+    try:
+        from mcp_service import create_app
+        mcp_app = create_app()
+        tools = []
+        for tool_name, tool_func in mcp_app.tools.items():
+            tools.append({
+                "name": tool_name,
+                "description": tool_func.__doc__ or "No description available"
+            })
+        return {"tools": tools}
+    except Exception as e:
+        return {"error": f"Failed to load tools: {str(e)}"}
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

requirements.txt

@@ -0,0 +1,5 @@
+fastmcp
+fastapi
+uvicorn[standard]
+pydantic>=2.0.0
+cached-property

run_docker.ps1

@@ -0,0 +1,35 @@
+cd $PSScriptRoot
+
+$ErrorActionPreference = "Stop"
+
+$entryName = if ($env:MCP_ENTRY_NAME) { $env:MCP_ENTRY_NAME } else { "whoosh" }
+$entryUrl  = if ($env:MCP_ENTRY_URL)  { $env:MCP_ENTRY_URL  } else { "http://localhost:7860/mcp" }
+$imageName = if ($env:MCP_IMAGE_NAME) { $env:MCP_IMAGE_NAME } else { "whoosh-mcp" }
+
+$mcpDir = Join-Path $env:USERPROFILE ".cursor"
+$mcpPath = Join-Path $mcpDir "mcp.json"
+if (!(Test-Path $mcpDir)) { New-Item -ItemType Directory -Path $mcpDir | Out-Null }
+
+$config = @{}
+if (Test-Path $mcpPath) {
+  try { $config = Get-Content $mcpPath -Raw | ConvertFrom-Json } catch { $config = @{} }
+}
+
+# Rebuild mcpServers as ordered and append the entry last
+$serversOrdered = [ordered]@{}
+if ($config -and ($config.PSObject.Properties.Name -contains "mcpServers") -and $config.mcpServers) {
+  $existing = $config.mcpServers
+  if ($existing -is [pscustomobject]) {
+    foreach ($p in $existing.PSObject.Properties) { if ($p.Name -ne $entryName) { $serversOrdered[$p.Name] = $p.Value } }
+  } elseif ($existing -is [System.Collections.IDictionary]) {
+    foreach ($k in $existing.Keys) { if ($k -ne $entryName) { $serversOrdered[$k] = $existing[$k] } }
+  }
+}
+$serversOrdered[$entryName] = @{ url = $entryUrl }
+$config = @{ mcpServers = $serversOrdered }
+
+$config | ConvertTo-Json -Depth 10 | Set-Content -Path $mcpPath -Encoding UTF8
+Write-Host ("Updated $entryName in " + $mcpPath + " -> " + $entryUrl)
+
+docker build -t $imageName .
+docker run --rm -p 7860:7860 $imageName

run_docker.sh

@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Switch to the directory where this script is located
+cd "$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+
+mcp_entry_name="${MCP_ENTRY_NAME:-whoosh}"
+mcp_entry_url="${MCP_ENTRY_URL:-http://localhost:7860/mcp}"
+mcp_dir="${HOME}/.cursor"
+mcp_path="${mcp_dir}/mcp.json"
+mkdir -p "${mcp_dir}"
+
+if command -v python3 >/dev/null 2>&1; then
+python3 - "${mcp_path}" "${mcp_entry_name}" "${mcp_entry_url}" <<'PY'
+import json, os, sys
+path, name, url = sys.argv[1:4]
+cfg = {"mcpServers": {}}
+if os.path.exists(path):
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            cfg = json.load(f)
+    except Exception:
+        cfg = {"mcpServers": {}}
+if not isinstance(cfg, dict):
+    cfg = {"mcpServers": {}}
+servers = cfg.get("mcpServers")
+if not isinstance(servers, dict):
+    servers = {}
+ordered = {}
+for k, v in servers.items():
+    if k != name:
+        ordered[k] = v
+ordered[name] = {"url": url}
+cfg = {"mcpServers": ordered}
+with open(path, "w", encoding="utf-8") as f:
+    json.dump(cfg, f, indent=2, ensure_ascii=False)
+PY
+elif command -v python >/dev/null 2>&1; then
+python - "${mcp_path}" "${mcp_entry_name}" "${mcp_entry_url}" <<'PY'
+import json, os, sys
+path, name, url = sys.argv[1:4]
+cfg = {"mcpServers": {}}
+if os.path.exists(path):
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            cfg = json.load(f)
+    except Exception:
+        cfg = {"mcpServers": {}}
+if not isinstance(cfg, dict):
+    cfg = {"mcpServers": {}}
+servers = cfg.get("mcpServers")
+if not isinstance(servers, dict):
+    servers = {}
+ordered = {}
+for k, v in servers.items():
+    if k != name:
+        ordered[k] = v
+ordered[name] = {"url": url}
+cfg = {"mcpServers": ordered}
+with open(path, "w", encoding="utf-8") as f:
+    json.dump(cfg, f, indent=2, ensure_ascii=False)
+PY
+elif command -v jq >/dev/null 2>&1; then
+  name="${mcp_entry_name}"; url="${mcp_entry_url}"
+  if [ -f "${mcp_path}" ]; then
+    tmp="$(mktemp)"
+    jq --arg name "$name" --arg url "$url" '
+      .mcpServers = (.mcpServers // {})
+      | .mcpServers as $s
+      | ($s | with_entries(select(.key != $name))) as $base
+      | .mcpServers = ($base + {($name): {"url": $url}})
+    ' "${mcp_path}" > "${tmp}" && mv "${tmp}" "${mcp_path}"
+  else
+    printf '{ "mcpServers": { "%s": { "url": "%s" } } }
+' "$name" "$url" > "${mcp_path}"
+  fi
+else
+  echo "Warning: neither python nor jq found; skipped updating ~/.cursor/mcp.json" >&2
+fi
+
+docker build -t whoosh-mcp .
+docker run --rm -p 7860:7860 whoosh-mcp

whoosh/mcp_output/README_MCP.md

@@ -0,0 +1,72 @@
+# Whoosh: Full-Text Search Engine Library
+
+## Project Introduction
+
+Whoosh is a fast, pure-Python full-text indexing, search, and spell-checking library developed by Matt Chaput. It provides a complete search engine solution that can index documents, parse complex queries, and return ranked search results. Key features include:
+
+- **Pure Python**: No external dependencies except for optional cached-property.
+- **Full-featured**: Includes indexing, searching, query parsing, highlighting, and spell checking.
+- **Flexible**: Supports multiple field types, custom analyzers, and pluggable components.
+- **Production-ready**: Used in real applications with support for concurrent access.
+
+## Installation Method
+
+To install Whoosh, ensure you have Python 3.6 or higher. You can install it using pip:
+
+```
+pip install Whoosh
+```
+
+## Quick Start
+
+Here's a quick guide to get you started with Whoosh:
+
+1. **Define a Schema**: Specify what fields your documents will have.
+2. **Create an Index**: Set up storage for your searchable data.
+3. **Add Documents**: Populate the index with your content.
+4. **Search**: Query the index and retrieve results.
+
+Example:
+
+```
+from whoosh.index import create_in
+from whoosh.fields import Schema, TEXT, ID
+
+schema = Schema(title=TEXT(stored=True), content=TEXT)
+index = create_in("indexdir", schema)
+
+# Add documents
+writer = index.writer()
+writer.add_document(title="First document", content="This is the first document we've added!")
+writer.commit()
+
+# Search
+from whoosh.qparser import QueryParser
+with index.searcher() as searcher:
+    query = QueryParser("content", index.schema).parse("first")
+    results = searcher.search(query)
+    for result in results:
+        print(result['title'])
+```
+
+## Available Tools and Endpoints List
+
+Whoosh provides several tools and services to enhance your search capabilities:
+
+- **IndexWriter**: For adding and updating documents in the index.
+- **IndexReader**: For reading and searching the index.
+- **QueryParser**: For parsing user queries into search objects.
+- **FileStorage**: For managing the storage of index files.
+- **Highlighting**: For generating highlighted snippets of search results.
+
+## Common Issues and Notes
+
+- **Dependencies**: Ensure Python 3.6 or higher is installed.
+- **Environment**: Whoosh is a pure-Python library and does not require additional dependencies, making it easy to integrate into various environments.
+- **Performance**: For large datasets, consider using multiprocessing to speed up indexing.
+
+## Reference Links or Documentation
+
+For more detailed information, visit the [Whoosh GitHub Repository](https://github.com/mchaput/whoosh) or refer to the [official documentation](https://whoosh.readthedocs.io/en/latest/).
+
+By following this guide, you should be able to set up and start using Whoosh for your full-text search needs efficiently.

whoosh/mcp_output/analysis.json

@@ -0,0 +1,3450 @@
+{
+  "summary": {
+    "repository_url": "https://github.com/mchaput/whoosh",
+    "summary": "Imported via zip fallback, file count: 167",
+    "file_tree": {
+      ".travis.yml": {
+        "size": 227
+      },
+      "LICENSE.txt": {
+        "size": 1482
+      },
+      "README.md": {
+        "size": 2422
+      },
+      "benchmark/dictionary.py": {
+        "size": 1258
+      },
+      "benchmark/enron.py": {
+        "size": 6452
+      },
+      "benchmark/marc21.py": {
+        "size": 9190
+      },
+      "benchmark/reuters.py": {
+        "size": 1211
+      },
+      "docs/source/conf.py": {
+        "size": 6396
+      },
+      "scripts/make_checkpoint.py": {
+        "size": 1832
+      },
+      "scripts/pylint.ini": {
+        "size": 8776
+      },
+      "scripts/read_checkpoint.py": {
+        "size": 1287
+      },
+      "setup.cfg": {
+        "size": 1123
+      },
+      "setup.py": {
+        "size": 1728
+      },
+      "src/whoosh/__init__.py": {
+        "size": 2059
+      },
+      "src/whoosh/analysis/__init__.py": {
+        "size": 3288
+      },
+      "src/whoosh/analysis/acore.py": {
+        "size": 5525
+      },
+      "src/whoosh/analysis/analyzers.py": {
+        "size": 11277
+      },
+      "src/whoosh/analysis/filters.py": {
+        "size": 16428
+      },
+      "src/whoosh/analysis/intraword.py": {
+        "size": 18991
+      },
+      "src/whoosh/analysis/morph.py": {
+        "size": 10125
+      },
+      "src/whoosh/analysis/ngrams.py": {
+        "size": 8788
+      },
+      "src/whoosh/analysis/tokenizers.py": {
+        "size": 12678
+      },
+      "src/whoosh/automata/__init__.py": {
+        "size": 0
+      },
+      "src/whoosh/automata/fsa.py": {
+        "size": 20430
+      },
+      "src/whoosh/automata/glob.py": {
+        "size": 3333
+      },
+      "src/whoosh/automata/lev.py": {
+        "size": 974
+      },
+      "src/whoosh/automata/nfa.py": {
+        "size": 10498
+      },
+      "src/whoosh/automata/reg.py": {
+        "size": 3974
+      },
+      "src/whoosh/classify.py": {
+        "size": 11916
+      },
+      "src/whoosh/codec/__init__.py": {
+        "size": 1649
+      },
+      "src/whoosh/codec/base.py": {
+        "size": 24192
+      },
+      "src/whoosh/codec/memory.py": {
+        "size": 11000
+      },
+      "src/whoosh/codec/plaintext.py": {
+        "size": 14256
+      },
+      "src/whoosh/codec/whoosh3.py": {
+        "size": 42743
+      },
+      "src/whoosh/collectors.py": {
+        "size": 42330
+      },
+      "src/whoosh/columns.py": {
+        "size": 47383
+      },
+      "src/whoosh/compat.py": {
+        "size": 5357
+      },
+      "src/whoosh/externalsort.py": {
+        "size": 7984
+      },
+      "src/whoosh/fields.py": {
+        "size": 56496
+      },
+      "src/whoosh/filedb/__init__.py": {
+        "size": 0
+      },
+      "src/whoosh/filedb/compound.py": {
+        "size": 11090
+      },
+      "src/whoosh/filedb/filestore.py": {
+        "size": 21584
+      },
+      "src/whoosh/filedb/filetables.py": {
+        "size": 25225
+      },
+      "src/whoosh/filedb/gae.py": {
+        "size": 4872
+      },
+      "src/whoosh/filedb/structfile.py": {
+        "size": 12453
+      },
+      "src/whoosh/formats.py": {
+        "size": 16706
+      },
+      "src/whoosh/highlight.py": {
+        "size": 38681
+      },
+      "src/whoosh/idsets.py": {
+        "size": 19109
+      },
+      "src/whoosh/index.py": {
+        "size": 24282
+      },
+      "src/whoosh/lang/__init__.py": {
+        "size": 4285
+      },
+      "src/whoosh/lang/dmetaphone.py": {
+        "size": 17520
+      },
+      "src/whoosh/lang/isri.py": {
+        "size": 16786
+      },
+      "src/whoosh/lang/lovins.py": {
+        "size": 12645
+      },
+      "src/whoosh/lang/morph_en.py": {
+        "size": 48468
+      },
+      "src/whoosh/lang/paicehusk.py": {
+        "size": 6788
+      },
+      "src/whoosh/lang/phonetic.py": {
+        "size": 3350
+      },
+      "src/whoosh/lang/porter.py": {
+        "size": 4231
+      },
+      "src/whoosh/lang/porter2.py": {
+        "size": 8314
+      },
+      "src/whoosh/lang/snowball/LICENSE.txt": {
+        "size": 574
+      },
+      "src/whoosh/lang/snowball/__init__.py": {
+        "size": 2622
+      },
+      "src/whoosh/lang/snowball/bases.py": {
+        "size": 4874
+      },
+      "src/whoosh/lang/snowball/danish.py": {
+        "size": 4112
+      },
+      "src/whoosh/lang/snowball/dutch.py": {
+        "size": 6194
+      },
+      "src/whoosh/lang/snowball/english.py": {
+        "size": 17347
+      },
+      "src/whoosh/lang/snowball/finnish.py": {
+        "size": 10074
+      },
+      "src/whoosh/lang/snowball/french.py": {
+        "size": 14461
+      },
+      "src/whoosh/lang/snowball/german.py": {
+        "size": 5347
+      },
+      "src/whoosh/lang/snowball/hungarian.py": {
+        "size": 11694
+      },
+      "src/whoosh/lang/snowball/italian.py": {
+        "size": 9125
+      },
+      "src/whoosh/lang/snowball/norwegian.py": {
+        "size": 2803
+      },
+      "src/whoosh/lang/snowball/portugese.py": {
+        "size": 8221
+      },
+      "src/whoosh/lang/snowball/romanian.py": {
+        "size": 11966
+      },
+      "src/whoosh/lang/snowball/russian.py": {
+        "size": 20904
+      },
+      "src/whoosh/lang/snowball/spanish.py": {
+        "size": 11013
+      },
+      "src/whoosh/lang/snowball/swedish.py": {
+        "size": 2760
+      },
+      "src/whoosh/lang/stopwords.py": {
+        "size": 15721
+      },
+      "src/whoosh/lang/wordnet.py": {
+        "size": 8672
+      },
+      "src/whoosh/legacy.py": {
+        "size": 3459
+      },
+      "src/whoosh/matching/__init__.py": {
+        "size": 1678
+      },
+      "src/whoosh/matching/binary.py": {
+        "size": 24449
+      },
+      "src/whoosh/matching/combo.py": {
+        "size": 9926
+      },
+      "src/whoosh/matching/mcore.py": {
+        "size": 18822
+      },
+      "src/whoosh/matching/wrappers.py": {
+        "size": 17477
+      },
+      "src/whoosh/multiproc.py": {
+        "size": 15128
+      },
+      "src/whoosh/qparser/__init__.py": {
+        "size": 1640
+      },
+      "src/whoosh/qparser/common.py": {
+        "size": 2408
+      },
+      "src/whoosh/qparser/dateparse.py": {
+        "size": 32771
+      },
+      "src/whoosh/qparser/default.py": {
+        "size": 17071
+      },
+      "src/whoosh/qparser/plugins.py": {
+        "size": 50402
+      },
+      "src/whoosh/qparser/syntax.py": {
+        "size": 18620
+      },
+      "src/whoosh/qparser/taggers.py": {
+        "size": 3624
+      },
+      "src/whoosh/query/__init__.py": {
+        "size": 1843
+      },
+      "src/whoosh/query/compound.py": {
+        "size": 22123
+      },
+      "src/whoosh/query/nested.py": {
+        "size": 15598
+      },
+      "src/whoosh/query/positional.py": {
+        "size": 9427
+      },
+      "src/whoosh/query/qcolumns.py": {
+        "size": 4197
+      },
+      "src/whoosh/query/qcore.py": {
+        "size": 23439
+      },
+      "src/whoosh/query/ranges.py": {
+        "size": 13420
+      },
+      "src/whoosh/query/spans.py": {
+        "size": 29069
+      },
+      "src/whoosh/query/terms.py": {
+        "size": 17880
+      },
+      "src/whoosh/query/wrappers.py": {
+        "size": 6740
+      },
+      "src/whoosh/reading.py": {
+        "size": 42427
+      },
+      "src/whoosh/scoring.py": {
+        "size": 20940
+      },
+      "src/whoosh/searching.py": {
+        "size": 64528
+      },
+      "src/whoosh/sorting.py": {
+        "size": 41941
+      },
+      "src/whoosh/spelling.py": {
+        "size": 12550
+      },
+      "src/whoosh/support/__init__.py": {
+        "size": 0
+      },
+      "src/whoosh/support/base85.py": {
+        "size": 2473
+      },
+      "src/whoosh/support/bench.py": {
+        "size": 21018
+      },
+      "src/whoosh/support/charset.py": {
+        "size": 79555
+      },
+      "src/whoosh/support/levenshtein.py": {
+        "size": 2385
+      },
+      "src/whoosh/support/relativedelta.py": {
+        "size": 17347
+      },
+      "src/whoosh/support/unicode.py": {
+        "size": 26604
+      },
+      "src/whoosh/system.py": {
+        "size": 2964
+      },
+      "src/whoosh/util/__init__.py": {
+        "size": 4411
+      },
+      "src/whoosh/util/cache.py": {
+        "size": 3874
+      },
+      "src/whoosh/util/filelock.py": {
+        "size": 5291
+      },
+      "src/whoosh/util/loading.py": {
+        "size": 3221
+      },
+      "src/whoosh/util/numeric.py": {
+        "size": 11285
+      },
+      "src/whoosh/util/numlists.py": {
+        "size": 10425
+      },
+      "src/whoosh/util/testing.py": {
+        "size": 4503
+      },
+      "src/whoosh/util/text.py": {
+        "size": 4372
+      },
+      "src/whoosh/util/times.py": {
+        "size": 16936
+      },
+      "src/whoosh/util/varints.py": {
+        "size": 3198
+      },
+      "src/whoosh/util/versions.py": {
+        "size": 5275
+      },
+      "src/whoosh/writing.py": {
+        "size": 46584
+      },
+      "stress/test_bigfacet.py": {
+        "size": 1306
+      },
+      "stress/test_bigindex.py": {
+        "size": 2236
+      },
+      "stress/test_bigsort.py": {
+        "size": 1556
+      },
+      "stress/test_bigtable.py": {
+        "size": 1024
+      },
+      "stress/test_hugeindex.py": {
+        "size": 1172
+      },
+      "stress/test_threading.py": {
+        "size": 1919
+      },
+      "stress/test_update.py": {
+        "size": 703
+      },
+      "tests/test_analysis.py": {
+        "size": 19093
+      },
+      "tests/test_automata.py": {
+        "size": 9660
+      },
+      "tests/test_bits.py": {
+        "size": 4379
+      },
+      "tests/test_classify.py": {
+        "size": 6928
+      },
+      "tests/test_codecs.py": {
+        "size": 19453
+      },
+      "tests/test_collector.py": {
+        "size": 8980
+      },
+      "tests/test_columns.py": {
+        "size": 10928
+      },
+      "tests/test_compound.py": {
+        "size": 1741
+      },
+      "tests/test_dateparse.py": {
+        "size": 16282
+      },
+      "tests/test_fields.py": {
+        "size": 20876
+      },
+      "tests/test_flexible.py": {
+        "size": 3671
+      },
+      "tests/test_highlighting.py": {
+        "size": 12647
+      },
+      "tests/test_indexing.py": {
+        "size": 26688
+      },
+      "tests/test_matching.py": {
+        "size": 17081
+      },
+      "tests/test_misc.py": {
+        "size": 4026
+      },
+      "tests/test_mpwriter.py": {
+        "size": 8467
+      },
+      "tests/test_nested.py": {
+        "size": 17227
+      },
+      "tests/test_parse_plugins.py": {
+        "size": 23464
+      },
+      "tests/test_parsing.py": {
+        "size": 34249
+      },
+      "tests/test_postings.py": {
+        "size": 4519
+      },
+      "tests/test_quality.py": {
+        "size": 5524
+      },
+      "tests/test_queries.py": {
+        "size": 21578
+      },
+      "tests/test_reading.py": {
+        "size": 16206
+      },
+      "tests/test_results.py": {
+        "size": 24078
+      },
+      "tests/test_searching.py": {
+        "size": 64863
+      },
+      "tests/test_sorting.py": {
+        "size": 38970
+      },
+      "tests/test_spans.py": {
+        "size": 12049
+      },
+      "tests/test_spelling.py": {
+        "size": 13120
+      },
+      "tests/test_stem.py": {
+        "size": 805
+      },
+      "tests/test_tables.py": {
+        "size": 6110
+      },
+      "tests/test_vectors.py": {
+        "size": 5051
+      },
+      "tests/test_weightings.py": {
+        "size": 2736
+      },
+      "tests/test_writing.py": {
+        "size": 17038
+      },
+      "tox.ini": {
+        "size": 128
+      }
+    },
+    "processed_by": "zip_fallback",
+    "success": true
+  },
+  "structure": {
+    "packages": [
+      "source.src.whoosh"
+    ]
+  },
+  "dependencies": {
+    "has_environment_yml": false,
+    "has_requirements_txt": false,
+    "pyproject": false,
+    "setup_cfg": true,
+    "setup_py": true
+  },
+  "entry_points": {
+    "imports": [],
+    "cli": [],
+    "modules": []
+  },
+  "llm_analysis": {
+    "core_modules": [
+      {
+        "package": "setup",
+        "module": "setup",
+        "functions": [],
+        "classes": [
+          "PyTest"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "benchmark",
+        "module": "dictionary",
+        "functions": [],
+        "classes": [
+          "VulgarTongue"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "benchmark",
+        "module": "enron",
+        "functions": [],
+        "classes": [
+          "Enron"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "benchmark",
+        "module": "marc21",
+        "functions": [
+          "author",
+          "getfields",
+          "isbn",
+          "joinsubfields",
+          "location",
+          "make_index",
+          "parse_record",
+          "physical",
+          "print_record",
+          "publisher",
+          "pubyear",
+          "read_file",
+          "read_record",
+          "search",
+          "subfield",
+          "subjects",
+          "title",
+          "uni",
+          "uniform_title"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "read_file": [
+            "dbfile",
+            "tags"
+          ],
+          "read_record": [
+            "filename",
+            "pos",
+            "tags"
+          ],
+          "parse_record": [
+            "data",
+            "tags"
+          ],
+          "subfield": [
+            "vs",
+            "code"
+          ],
+          "joinsubfields": [
+            "vs"
+          ],
+          "getfields": [
+            "d"
+          ],
+          "title": [
+            "d"
+          ],
+          "isbn": [
+            "d"
+          ],
+          "author": [
+            "d"
+          ],
+          "uniform_title": [
+            "d"
+          ],
+          "subjects": [
+            "d"
+          ],
+          "physical": [
+            "d"
+          ],
+          "location": [
+            "d"
+          ],
+          "publisher": [
+            "d"
+          ],
+          "pubyear": [
+            "d"
+          ],
+          "uni": [
+            "v"
+          ],
+          "make_index": [
+            "basedir",
+            "ixdir",
+            "procs",
+            "limitmb",
+            "multisegment",
+            "glob"
+          ],
+          "print_record": [
+            "no",
+            "basedir",
+            "filename",
+            "pos"
+          ],
+          "search": [
+            "qstring",
+            "ixdir",
+            "basedir",
+            "limit",
+            "optimize",
+            "scores"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "benchmark",
+        "module": "reuters",
+        "functions": [],
+        "classes": [
+          "Reuters"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src",
+        "module": "whoosh",
+        "functions": [
+          "versionstring"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "versionstring": [
+            "build",
+            "extra"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "classify",
+        "functions": [
+          "hamming_distance",
+          "kmeans",
+          "shingles",
+          "simhash",
+          "swin",
+          "two_pass_variance",
+          "weighted_incremental_variance"
+        ],
+        "classes": [
+          "Bo1Model",
+          "Bo2Model",
+          "Expander",
+          "ExpansionModel",
+          "KLModel"
+        ],
+        "function_signatures": {
+          "shingles": [
+            "input",
+            "size"
+          ],
+          "simhash": [
+            "features",
+            "hashbits"
+          ],
+          "hamming_distance": [
+            "first_hash",
+            "other_hash",
+            "hashbits"
+          ],
+          "kmeans": [
+            "data",
+            "k",
+            "t",
+            "distfun",
+            "maxiter",
+            "centers"
+          ],
+          "two_pass_variance": [
+            "data"
+          ],
+          "weighted_incremental_variance": [
+            "data_weight_pairs"
+          ],
+          "swin": [
+            "data",
+            "size"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "collectors",
+        "functions": [
+          "ilen"
+        ],
+        "classes": [
+          "CollapseCollector",
+          "Collector",
+          "FacetCollector",
+          "FilterCollector",
+          "ScoredCollector",
+          "SortingCollector",
+          "TermsCollector",
+          "TimeLimitCollector",
+          "TopCollector",
+          "UnlimitedCollector",
+          "UnsortedCollector",
+          "WrappingCollector"
+        ],
+        "function_signatures": {
+          "ilen": [
+            "iterator"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "columns",
+        "functions": [],
+        "classes": [
+          "BitColumn",
+          "ClampedNumericColumn",
+          "Column",
+          "ColumnReader",
+          "ColumnWriter",
+          "CompressedBlockColumn",
+          "CompressedBytesColumn",
+          "EmptyColumnReader",
+          "FixedBytesColumn",
+          "FixedBytesListColumn",
+          "ListColumn",
+          "ListColumnReader",
+          "MultiColumnReader",
+          "NumericColumn",
+          "PickleColumn",
+          "RefBytesColumn",
+          "StructColumn",
+          "TranslatingColumnReader",
+          "VarBytesColumn",
+          "VarBytesListColumn",
+          "WrappedColumn",
+          "WrappedColumnReader",
+          "WrappedColumnWriter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "compat",
+        "functions": [
+          "htmlescape"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "htmlescape": [
+            "s",
+            "quote"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "externalsort",
+        "functions": [
+          "sort"
+        ],
+        "classes": [
+          "SortingPool"
+        ],
+        "function_signatures": {
+          "sort": [
+            "items",
+            "maxsize",
+            "tempdir",
+            "maxfiles"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "fields",
+        "functions": [
+          "ensure_schema",
+          "merge_fielddict",
+          "merge_schema",
+          "merge_schemas"
+        ],
+        "classes": [
+          "BOOLEAN",
+          "COLUMN",
+          "DATETIME",
+          "FieldConfigurationError",
+          "FieldType",
+          "FieldWrapper",
+          "ID",
+          "IDLIST",
+          "KEYWORD",
+          "MetaSchema",
+          "NGRAM",
+          "NGRAMWORDS",
+          "NUMERIC",
+          "ReverseField",
+          "STORED",
+          "Schema",
+          "SchemaClass",
+          "SpellField",
+          "TEXT",
+          "UnknownFieldError"
+        ],
+        "function_signatures": {
+          "ensure_schema": [
+            "schema"
+          ],
+          "merge_fielddict": [
+            "d1",
+            "d2"
+          ],
+          "merge_schema": [
+            "s1",
+            "s2"
+          ],
+          "merge_schemas": [
+            "schemas"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "formats",
+        "functions": [
+          "tokens"
+        ],
+        "classes": [
+          "CharacterBoosts",
+          "Characters",
+          "Existence",
+          "Format",
+          "Frequency",
+          "PositionBoosts",
+          "Positions"
+        ],
+        "function_signatures": {
+          "tokens": [
+            "value",
+            "analyzer",
+            "kwargs"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "highlight",
+        "functions": [
+          "FIRST",
+          "LONGER",
+          "SCORE",
+          "SHORTER",
+          "get_text",
+          "highlight",
+          "mkfrag",
+          "set_matched_filter",
+          "set_matched_filter_phrases",
+          "top_fragments"
+        ],
+        "classes": [
+          "BasicFragmentScorer",
+          "ContextFragmenter",
+          "Formatter",
+          "Fragment",
+          "FragmentScorer",
+          "Fragmenter",
+          "GenshiFormatter",
+          "Highlighter",
+          "HtmlFormatter",
+          "NullFormatter",
+          "PinpointFragmenter",
+          "SentenceFragmenter",
+          "UppercaseFormatter",
+          "WholeFragmenter"
+        ],
+        "function_signatures": {
+          "mkfrag": [
+            "text",
+            "tokens",
+            "startchar",
+            "endchar",
+            "charsbefore",
+            "charsafter"
+          ],
+          "set_matched_filter": [
+            "tokens",
+            "termset"
+          ],
+          "set_matched_filter_phrases": [
+            "tokens",
+            "text",
+            "terms",
+            "phrases"
+          ],
+          "SCORE": [
+            "fragment"
+          ],
+          "FIRST": [
+            "fragment"
+          ],
+          "LONGER": [
+            "fragment"
+          ],
+          "SHORTER": [
+            "fragment"
+          ],
+          "get_text": [
+            "original",
+            "token",
+            "replace"
+          ],
+          "top_fragments": [
+            "fragments",
+            "count",
+            "scorer",
+            "order",
+            "minscore"
+          ],
+          "highlight": [
+            "text",
+            "terms",
+            "analyzer",
+            "fragmenter",
+            "formatter",
+            "top",
+            "scorer",
+            "minscore",
+            "order",
+            "mode"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "idsets",
+        "functions": [],
+        "classes": [
+          "BaseBitSet",
+          "BitSet",
+          "DocIdSet",
+          "MultiIdSet",
+          "OnDiskBitSet",
+          "ReverseIdSet",
+          "RoaringIdSet",
+          "SortedIntSet"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "index",
+        "functions": [
+          "clean_files",
+          "create_in",
+          "exists",
+          "exists_in",
+          "open_dir",
+          "version",
+          "version_in"
+        ],
+        "classes": [
+          "EmptyIndexError",
+          "FileIndex",
+          "Index",
+          "IndexError",
+          "IndexVersionError",
+          "LockError",
+          "OutOfDateError",
+          "TOC"
+        ],
+        "function_signatures": {
+          "create_in": [
+            "dirname",
+            "schema",
+            "indexname"
+          ],
+          "open_dir": [
+            "dirname",
+            "indexname",
+            "readonly",
+            "schema"
+          ],
+          "exists_in": [
+            "dirname",
+            "indexname"
+          ],
+          "exists": [
+            "storage",
+            "indexname"
+          ],
+          "version_in": [
+            "dirname",
+            "indexname"
+          ],
+          "version": [
+            "storage",
+            "indexname"
+          ],
+          "clean_files": [
+            "storage",
+            "indexname",
+            "gen",
+            "segments"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "legacy",
+        "functions": [
+          "load_110_toc"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "load_110_toc": [
+            "stream",
+            "gen",
+            "schema",
+            "version"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "multiproc",
+        "functions": [
+          "finish_subsegment"
+        ],
+        "classes": [
+          "MpWriter",
+          "MultiSegmentWriter",
+          "SerialMpWriter",
+          "SubWriterTask"
+        ],
+        "function_signatures": {
+          "finish_subsegment": [
+            "writer",
+            "k"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "reading",
+        "functions": [
+          "combine_terminfos"
+        ],
+        "classes": [
+          "EmptyReader",
+          "IndexReader",
+          "MultiCursor",
+          "MultiReader",
+          "ReaderClosed",
+          "SegmentReader",
+          "TermInfo",
+          "TermNotFound"
+        ],
+        "function_signatures": {
+          "combine_terminfos": [
+            "tis"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "scoring",
+        "functions": [
+          "bm25",
+          "dfree",
+          "pl2"
+        ],
+        "classes": [
+          "BM25F",
+          "BM25FScorer",
+          "BaseScorer",
+          "DFree",
+          "DFreeScorer",
+          "DebugModel",
+          "DebugScorer",
+          "Frequency",
+          "FunctionWeighting",
+          "MultiWeighting",
+          "PL2",
+          "PL2Scorer",
+          "ReverseWeighting",
+          "TF_IDF",
+          "TF_IDFScorer",
+          "WeightLengthScorer",
+          "WeightScorer",
+          "Weighting",
+          "WeightingModel"
+        ],
+        "function_signatures": {
+          "bm25": [
+            "idf",
+            "tf",
+            "fl",
+            "avgfl",
+            "B",
+            "K1"
+          ],
+          "dfree": [
+            "tf",
+            "cf",
+            "qf",
+            "dl",
+            "fl"
+          ],
+          "pl2": [
+            "tf",
+            "cf",
+            "qf",
+            "dc",
+            "fl",
+            "avgfl",
+            "c"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "searching",
+        "functions": [],
+        "classes": [
+          "Hit",
+          "NoTermsException",
+          "Results",
+          "ResultsPage",
+          "SearchContext",
+          "Searcher",
+          "TimeLimit"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "sorting",
+        "functions": [
+          "add_sortable"
+        ],
+        "classes": [
+          "Best",
+          "Categorizer",
+          "ColumnCategorizer",
+          "Count",
+          "DateRangeFacet",
+          "FacetMap",
+          "FacetType",
+          "Facets",
+          "FieldFacet",
+          "FunctionFacet",
+          "MultiFacet",
+          "OrderedList",
+          "OverlappingCategorizer",
+          "PostingCategorizer",
+          "QueryFacet",
+          "RangeFacet",
+          "ReversedColumnCategorizer",
+          "ScoreFacet",
+          "StoredFieldFacet",
+          "TranslateFacet",
+          "UnorderedList"
+        ],
+        "function_signatures": {
+          "add_sortable": [
+            "writer",
+            "fieldname",
+            "facet",
+            "column"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "spelling",
+        "functions": [],
+        "classes": [
+          "Correction",
+          "Corrector",
+          "ListCorrector",
+          "MultiCorrector",
+          "QueryCorrector",
+          "ReaderCorrector",
+          "SimpleQueryCorrector"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "writing",
+        "functions": [
+          "CLEAR",
+          "MERGE_SMALL",
+          "NO_MERGE",
+          "OPTIMIZE",
+          "add_spelling",
+          "groupmanager"
+        ],
+        "classes": [
+          "AsyncWriter",
+          "BufferedWriter",
+          "IndexWriter",
+          "IndexingError",
+          "PostingPool",
+          "SegmentWriter"
+        ],
+        "function_signatures": {
+          "groupmanager": [
+            "writer"
+          ],
+          "NO_MERGE": [
+            "writer",
+            "segments"
+          ],
+          "MERGE_SMALL": [
+            "writer",
+            "segments"
+          ],
+          "OPTIMIZE": [
+            "writer",
+            "segments"
+          ],
+          "CLEAR": [
+            "writer",
+            "segments"
+          ],
+          "add_spelling": [
+            "ix",
+            "fieldnames",
+            "commit"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.analysis",
+        "module": "acore",
+        "functions": [
+          "entoken",
+          "unstopped"
+        ],
+        "classes": [
+          "Composable",
+          "CompositionError",
+          "Token"
+        ],
+        "function_signatures": {
+          "unstopped": [
+            "tokenstream"
+          ],
+          "entoken": [
+            "textstream",
+            "positions",
+            "chars",
+            "start_pos",
+            "start_char"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.analysis",
+        "module": "analyzers",
+        "functions": [
+          "FancyAnalyzer",
+          "IDAnalyzer",
+          "KeywordAnalyzer",
+          "LanguageAnalyzer",
+          "RegexAnalyzer",
+          "SimpleAnalyzer",
+          "StandardAnalyzer",
+          "StemmingAnalyzer"
+        ],
+        "classes": [
+          "Analyzer",
+          "CompositeAnalyzer"
+        ],
+        "function_signatures": {
+          "IDAnalyzer": [
+            "lowercase"
+          ],
+          "KeywordAnalyzer": [
+            "lowercase",
+            "commas"
+          ],
+          "RegexAnalyzer": [
+            "expression",
+            "gaps"
+          ],
+          "SimpleAnalyzer": [
+            "expression",
+            "gaps"
+          ],
+          "StandardAnalyzer": [
+            "expression",
+            "stoplist",
+            "minsize",
+            "maxsize",
+            "gaps"
+          ],
+          "StemmingAnalyzer": [
+            "expression",
+            "stoplist",
+            "minsize",
+            "maxsize",
+            "gaps",
+            "stemfn",
+            "ignore",
+            "cachesize"
+          ],
+          "FancyAnalyzer": [
+            "expression",
+            "stoplist",
+            "minsize",
+            "maxsize",
+            "gaps",
+            "splitwords",
+            "splitnums",
+            "mergewords",
+            "mergenums"
+          ],
+          "LanguageAnalyzer": [
+            "lang",
+            "expression",
+            "gaps",
+            "cachesize"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.analysis",
+        "module": "filters",
+        "functions": [],
+        "classes": [
+          "CharsetFilter",
+          "DelimitedAttributeFilter",
+          "Filter",
+          "LoggingFilter",
+          "LowercaseFilter",
+          "MultiFilter",
+          "PassFilter",
+          "ReverseTextFilter",
+          "StopFilter",
+          "StripFilter",
+          "SubstitutionFilter",
+          "TeeFilter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.analysis",
+        "module": "intraword",
+        "functions": [],
+        "classes": [
+          "BiWordFilter",
+          "CompoundWordFilter",
+          "IntraWordFilter",
+          "ShingleFilter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.analysis",
+        "module": "morph",
+        "functions": [],
+        "classes": [
+          "DoubleMetaphoneFilter",
+          "PyStemmerFilter",
+          "StemFilter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.analysis",
+        "module": "ngrams",
+        "functions": [
+          "NgramAnalyzer",
+          "NgramWordAnalyzer"
+        ],
+        "classes": [
+          "NgramFilter",
+          "NgramTokenizer"
+        ],
+        "function_signatures": {
+          "NgramAnalyzer": [
+            "minsize",
+            "maxsize"
+          ],
+          "NgramWordAnalyzer": [
+            "minsize",
+            "maxsize",
+            "tokenizer",
+            "at"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.analysis",
+        "module": "tokenizers",
+        "functions": [
+          "CommaSeparatedTokenizer",
+          "SpaceSeparatedTokenizer"
+        ],
+        "classes": [
+          "CharsetTokenizer",
+          "IDTokenizer",
+          "PathTokenizer",
+          "RegexTokenizer",
+          "Tokenizer"
+        ],
+        "function_signatures": {
+          "SpaceSeparatedTokenizer": [],
+          "CommaSeparatedTokenizer": []
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.automata",
+        "module": "fsa",
+        "functions": [
+          "add_suffix",
+          "basic_nfa",
+          "charset_nfa",
+          "choice_nfa",
+          "concat_nfa",
+          "dot_nfa",
+          "epsilon_nfa",
+          "find_all_matches",
+          "intersection",
+          "optional_nfa",
+          "plus_nfa",
+          "product",
+          "renumber_dfa",
+          "reverse_nfa",
+          "star_nfa",
+          "string_nfa",
+          "strings_dfa",
+          "u_to_utf8",
+          "union"
+        ],
+        "classes": [
+          "DFA",
+          "DMNode",
+          "FSA",
+          "Marker",
+          "NFA"
+        ],
+        "function_signatures": {
+          "renumber_dfa": [
+            "dfa",
+            "base"
+          ],
+          "u_to_utf8": [
+            "dfa",
+            "base"
+          ],
+          "find_all_matches": [
+            "dfa",
+            "lookup_func",
+            "first"
+          ],
+          "reverse_nfa": [
+            "n"
+          ],
+          "product": [
+            "dfa1",
+            "op",
+            "dfa2"
+          ],
+          "intersection": [
+            "dfa1",
+            "dfa2"
+          ],
+          "union": [
+            "dfa1",
+            "dfa2"
+          ],
+          "epsilon_nfa": [],
+          "dot_nfa": [],
+          "basic_nfa": [
+            "label"
+          ],
+          "charset_nfa": [
+            "labels"
+          ],
+          "string_nfa": [
+            "string"
+          ],
+          "choice_nfa": [
+            "n1",
+            "n2"
+          ],
+          "concat_nfa": [
+            "n1",
+            "n2"
+          ],
+          "star_nfa": [
+            "n"
+          ],
+          "plus_nfa": [
+            "n"
+          ],
+          "optional_nfa": [
+            "n"
+          ],
+          "strings_dfa": [
+            "strings"
+          ],
+          "add_suffix": [
+            "dfa",
+            "nodes",
+            "last",
+            "downto",
+            "seen"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.automata",
+        "module": "glob",
+        "functions": [
+          "glob_automaton",
+          "parse_glob"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "parse_glob": [
+            "pattern",
+            "_glob_multi",
+            "_glob_single",
+            "_glob_range1",
+            "_glob_range2"
+          ],
+          "glob_automaton": [
+            "pattern"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.automata",
+        "module": "lev",
+        "functions": [
+          "levenshtein_automaton"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "levenshtein_automaton": [
+            "term",
+            "k",
+            "prefix"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.automata",
+        "module": "nfa",
+        "functions": [
+          "advance",
+          "alt",
+          "concat",
+          "fixup",
+          "one_or_more",
+          "regex_limit",
+          "run",
+          "zero_or_more",
+          "zero_or_one"
+        ],
+        "classes": [
+          "Any",
+          "Char",
+          "Instruction",
+          "Jmp",
+          "Label",
+          "Lit",
+          "Match",
+          "Split",
+          "Thread",
+          "ThreadList"
+        ],
+        "function_signatures": {
+          "concat": [
+            "e1",
+            "e2"
+          ],
+          "alt": [
+            "e1",
+            "e2"
+          ],
+          "zero_or_one": [
+            "e"
+          ],
+          "zero_or_more": [
+            "e"
+          ],
+          "one_or_more": [
+            "e"
+          ],
+          "fixup": [
+            "program"
+          ],
+          "advance": [
+            "thread",
+            "arc",
+            "c"
+          ],
+          "run": [
+            "graph",
+            "program",
+            "address"
+          ],
+          "regex_limit": [
+            "graph",
+            "mode",
+            "program",
+            "address"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.automata",
+        "module": "reg",
+        "functions": [
+          "parse"
+        ],
+        "classes": [
+          "RegexBuilder"
+        ],
+        "function_signatures": {
+          "parse": [
+            "pattern"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "codec",
+        "functions": [
+          "default_codec"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "default_codec": []
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.codec",
+        "module": "base",
+        "functions": [],
+        "classes": [
+          "Automata",
+          "Codec",
+          "EmptyCursor",
+          "FieldCursor",
+          "FieldWriter",
+          "MultiPerDocumentReader",
+          "OutOfOrderError",
+          "PerDocWriterWithColumns",
+          "PerDocumentReader",
+          "PerDocumentWriter",
+          "PostingsWriter",
+          "Segment",
+          "TermsReader",
+          "WrappingCodec",
+          "WrappingSegment"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.codec",
+        "module": "memory",
+        "functions": [],
+        "classes": [
+          "MemFieldWriter",
+          "MemPerDocReader",
+          "MemPerDocWriter",
+          "MemSegment",
+          "MemTermsReader",
+          "MemWriter",
+          "MemoryCodec"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.codec",
+        "module": "plaintext",
+        "functions": [],
+        "classes": [
+          "LineReader",
+          "LineWriter",
+          "PlainFieldWriter",
+          "PlainPerDocReader",
+          "PlainPerDocWriter",
+          "PlainSegment",
+          "PlainTermsReader",
+          "PlainTextCodec"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.codec",
+        "module": "whoosh3",
+        "functions": [],
+        "classes": [
+          "W3Codec",
+          "W3FieldCursor",
+          "W3FieldWriter",
+          "W3LeafMatcher",
+          "W3PerDocReader",
+          "W3PerDocWriter",
+          "W3PostingsWriter",
+          "W3Segment",
+          "W3TermInfo",
+          "W3TermsReader"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.filedb",
+        "module": "compound",
+        "functions": [],
+        "classes": [
+          "CompoundStorage",
+          "CompoundWriter",
+          "SubFile"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.filedb",
+        "module": "filestore",
+        "functions": [
+          "copy_storage",
+          "copy_to_ram"
+        ],
+        "classes": [
+          "FileStorage",
+          "OverlayStorage",
+          "RamStorage",
+          "ReadOnlyError",
+          "Storage",
+          "StorageError"
+        ],
+        "function_signatures": {
+          "copy_storage": [
+            "sourcestore",
+            "deststore"
+          ],
+          "copy_to_ram": [
+            "storage"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.filedb",
+        "module": "filetables",
+        "functions": [
+          "cdb_hash",
+          "crc_hash",
+          "md5_hash"
+        ],
+        "classes": [
+          "FieldedOrderedHashReader",
+          "FieldedOrderedHashWriter",
+          "FileFormatError",
+          "HashReader",
+          "HashWriter",
+          "OrderedHashReader",
+          "OrderedHashWriter"
+        ],
+        "function_signatures": {
+          "cdb_hash": [
+            "key"
+          ],
+          "md5_hash": [
+            "key"
+          ],
+          "crc_hash": [
+            "key"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.filedb",
+        "module": "gae",
+        "functions": [],
+        "classes": [
+          "DatastoreFile",
+          "DatastoreStorage",
+          "MemcacheLock"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.filedb",
+        "module": "structfile",
+        "functions": [],
+        "classes": [
+          "BufferFile",
+          "ChecksumFile",
+          "StructFile"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "lang",
+        "functions": [
+          "has_stemmer",
+          "has_stopwords",
+          "stemmer_for_language",
+          "stopwords_for_language",
+          "two_letter_code"
+        ],
+        "classes": [
+          "NoStemmer",
+          "NoStopWords"
+        ],
+        "function_signatures": {
+          "two_letter_code": [
+            "name"
+          ],
+          "has_stemmer": [
+            "lang"
+          ],
+          "has_stopwords": [
+            "lang"
+          ],
+          "stemmer_for_language": [
+            "lang"
+          ],
+          "stopwords_for_language": [
+            "lang"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang",
+        "module": "dmetaphone",
+        "functions": [
+          "double_metaphone"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "double_metaphone": [
+            "text"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang",
+        "module": "isri",
+        "functions": [],
+        "classes": [
+          "ISRIStemmer"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang",
+        "module": "lovins",
+        "functions": [
+          "A",
+          "B",
+          "C",
+          "D",
+          "E",
+          "F",
+          "G",
+          "H",
+          "I",
+          "J",
+          "K",
+          "L",
+          "M",
+          "N",
+          "O",
+          "P",
+          "Q",
+          "R",
+          "S",
+          "T",
+          "U",
+          "V",
+          "W",
+          "X",
+          "Y",
+          "Z",
+          "a",
+          "b",
+          "c",
+          "fix_ending",
+          "remove_ending",
+          "stem"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "A": [
+            "base"
+          ],
+          "B": [
+            "base"
+          ],
+          "C": [
+            "base"
+          ],
+          "D": [
+            "base"
+          ],
+          "E": [
+            "base"
+          ],
+          "F": [
+            "base"
+          ],
+          "G": [
+            "base"
+          ],
+          "H": [
+            "base"
+          ],
+          "I": [
+            "base"
+          ],
+          "J": [
+            "base"
+          ],
+          "K": [
+            "base"
+          ],
+          "L": [
+            "base"
+          ],
+          "M": [
+            "base"
+          ],
+          "N": [
+            "base"
+          ],
+          "O": [
+            "base"
+          ],
+          "P": [
+            "base"
+          ],
+          "Q": [
+            "base"
+          ],
+          "R": [
+            "base"
+          ],
+          "S": [
+            "base"
+          ],
+          "T": [
+            "base"
+          ],
+          "U": [
+            "base"
+          ],
+          "V": [
+            "base"
+          ],
+          "W": [
+            "base"
+          ],
+          "X": [
+            "base"
+          ],
+          "Y": [
+            "base"
+          ],
+          "Z": [
+            "base"
+          ],
+          "a": [
+            "base"
+          ],
+          "b": [
+            "base"
+          ],
+          "c": [
+            "base"
+          ],
+          "remove_ending": [
+            "word"
+          ],
+          "fix_ending": [
+            "word"
+          ],
+          "stem": [
+            "word"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang",
+        "module": "morph_en",
+        "functions": [
+          "variations"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "variations": [
+            "word"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang",
+        "module": "paicehusk",
+        "functions": [],
+        "classes": [
+          "PaiceHuskStemmer"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang",
+        "module": "phonetic",
+        "functions": [
+          "soundex_ar",
+          "soundex_en",
+          "soundex_esp"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "soundex_en": [
+            "word"
+          ],
+          "soundex_esp": [
+            "word"
+          ],
+          "soundex_ar": [
+            "word"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang",
+        "module": "porter",
+        "functions": [
+          "stem"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "stem": [
+            "w"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang",
+        "module": "porter2",
+        "functions": [
+          "capitalize_consonant_ys",
+          "ends_with_double",
+          "ends_with_short_syllable",
+          "get_r1",
+          "get_r2",
+          "is_short_word",
+          "normalize_ys",
+          "remove_initial_apostrophe",
+          "stem",
+          "step_0",
+          "step_1a",
+          "step_1b",
+          "step_1b_helper",
+          "step_1c",
+          "step_2",
+          "step_2_helper",
+          "step_3",
+          "step_3_helper",
+          "step_4",
+          "step_5"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "get_r1": [
+            "word"
+          ],
+          "get_r2": [
+            "word"
+          ],
+          "ends_with_short_syllable": [
+            "word"
+          ],
+          "is_short_word": [
+            "word"
+          ],
+          "remove_initial_apostrophe": [
+            "word"
+          ],
+          "capitalize_consonant_ys": [
+            "word"
+          ],
+          "step_0": [
+            "word"
+          ],
+          "step_1a": [
+            "word"
+          ],
+          "ends_with_double": [
+            "word"
+          ],
+          "step_1b_helper": [
+            "word"
+          ],
+          "step_1b": [
+            "word",
+            "r1"
+          ],
+          "step_1c": [
+            "word"
+          ],
+          "step_2_helper": [
+            "word",
+            "r1",
+            "end",
+            "repl",
+            "prev"
+          ],
+          "step_2": [
+            "word",
+            "r1"
+          ],
+          "step_3_helper": [
+            "word",
+            "r1",
+            "r2",
+            "end",
+            "repl",
+            "r2_necessary"
+          ],
+          "step_3": [
+            "word",
+            "r1",
+            "r2"
+          ],
+          "step_4": [
+            "word",
+            "r2"
+          ],
+          "step_5": [
+            "word",
+            "r1",
+            "r2"
+          ],
+          "normalize_ys": [
+            "word"
+          ],
+          "stem": [
+            "word"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang",
+        "module": "wordnet",
+        "functions": [
+          "make_index",
+          "parse_file",
+          "synonyms"
+        ],
+        "classes": [
+          "Thesaurus"
+        ],
+        "function_signatures": {
+          "parse_file": [
+            "f"
+          ],
+          "make_index": [
+            "storage",
+            "indexname",
+            "word2nums",
+            "num2words"
+          ],
+          "synonyms": [
+            "word2nums",
+            "num2words",
+            "word"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang.snowball",
+        "module": "danish",
+        "functions": [],
+        "classes": [
+          "DanishStemmer"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang.snowball",
+        "module": "dutch",
+        "functions": [],
+        "classes": [
+          "DutchStemmer"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang.snowball",
+        "module": "english",
+        "functions": [],
+        "classes": [
+          "EnglishStemmer"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang.snowball",
+        "module": "finnish",
+        "functions": [],
+        "classes": [
+          "FinnishStemmer"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang.snowball",
+        "module": "french",
+        "functions": [],
+        "classes": [
+          "FrenchStemmer"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang.snowball",
+        "module": "german",
+        "functions": [],
+        "classes": [
+          "GermanStemmer"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang.snowball",
+        "module": "hungarian",
+        "functions": [],
+        "classes": [
+          "HungarianStemmer"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang.snowball",
+        "module": "italian",
+        "functions": [],
+        "classes": [
+          "ItalianStemmer"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang.snowball",
+        "module": "norwegian",
+        "functions": [],
+        "classes": [
+          "NorwegianStemmer"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang.snowball",
+        "module": "portugese",
+        "functions": [],
+        "classes": [
+          "PortugueseStemmer"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang.snowball",
+        "module": "romanian",
+        "functions": [],
+        "classes": [
+          "RomanianStemmer"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang.snowball",
+        "module": "russian",
+        "functions": [],
+        "classes": [
+          "RussianStemmer"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang.snowball",
+        "module": "spanish",
+        "functions": [],
+        "classes": [
+          "SpanishStemmer"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.lang.snowball",
+        "module": "swedish",
+        "functions": [],
+        "classes": [
+          "SwedishStemmer"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.matching",
+        "module": "binary",
+        "functions": [],
+        "classes": [
+          "AdditiveBiMatcher",
+          "AndMaybeMatcher",
+          "AndNotMatcher",
+          "BiMatcher",
+          "DisjunctionMaxMatcher",
+          "IntersectionMatcher",
+          "UnionMatcher"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.matching",
+        "module": "combo",
+        "functions": [],
+        "classes": [
+          "ArrayUnionMatcher",
+          "CombinationMatcher",
+          "PreloadedUnionMatcher"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.matching",
+        "module": "mcore",
+        "functions": [],
+        "classes": [
+          "ConstantScoreMatcher",
+          "LeafMatcher",
+          "ListMatcher",
+          "Matcher",
+          "NoQualityAvailable",
+          "NullMatcherClass",
+          "ReadTooFar"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.matching",
+        "module": "wrappers",
+        "functions": [
+          "ExcludeMatcher"
+        ],
+        "classes": [
+          "ConstantScoreWrapperMatcher",
+          "CoordMatcher",
+          "FilterMatcher",
+          "InverseMatcher",
+          "MultiMatcher",
+          "RequireMatcher",
+          "SingleTermMatcher",
+          "WrappingMatcher"
+        ],
+        "function_signatures": {
+          "ExcludeMatcher": [
+            "child",
+            "excluded",
+            "boost"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.qparser",
+        "module": "common",
+        "functions": [
+          "attach",
+          "get_single_text",
+          "print_debug"
+        ],
+        "classes": [
+          "QueryParserError"
+        ],
+        "function_signatures": {
+          "get_single_text": [
+            "field",
+            "text"
+          ],
+          "attach": [
+            "q",
+            "stxnode"
+          ],
+          "print_debug": [
+            "level",
+            "msg",
+            "out"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.qparser",
+        "module": "dateparse",
+        "functions": [
+          "print_debug"
+        ],
+        "classes": [
+          "Bag",
+          "Choice",
+          "Combo",
+          "DateParseError",
+          "DateParser",
+          "DateParserPlugin",
+          "DateRangeNode",
+          "DateTagger",
+          "DateTimeNode",
+          "Daynames",
+          "English",
+          "Month",
+          "MultiBase",
+          "Optional",
+          "ParserBase",
+          "PlusMinus",
+          "Props",
+          "Regex",
+          "Sequence",
+          "Time12",
+          "ToEnd"
+        ],
+        "function_signatures": {
+          "print_debug": [
+            "level",
+            "msg"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.qparser",
+        "module": "default",
+        "functions": [
+          "DisMaxParser",
+          "MultifieldParser",
+          "SimpleParser"
+        ],
+        "classes": [
+          "QueryParser"
+        ],
+        "function_signatures": {
+          "MultifieldParser": [
+            "fieldnames",
+            "schema",
+            "fieldboosts"
+          ],
+          "SimpleParser": [
+            "fieldname",
+            "schema"
+          ],
+          "DisMaxParser": [
+            "fieldboosts",
+            "schema",
+            "tiebreak"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.qparser",
+        "module": "plugins",
+        "functions": [],
+        "classes": [
+          "BoostPlugin",
+          "CopyFieldPlugin",
+          "EveryPlugin",
+          "FieldAliasPlugin",
+          "FieldsPlugin",
+          "FunctionPlugin",
+          "FuzzyTermPlugin",
+          "GroupPlugin",
+          "GtLtPlugin",
+          "MultifieldPlugin",
+          "OperatorsPlugin",
+          "PhrasePlugin",
+          "Plugin",
+          "PlusMinusPlugin",
+          "PrefixPlugin",
+          "PseudoFieldPlugin",
+          "RangePlugin",
+          "RegexPlugin",
+          "SequencePlugin",
+          "SingleQuotePlugin",
+          "TaggingPlugin",
+          "WhitespacePlugin",
+          "WildcardPlugin"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.qparser",
+        "module": "syntax",
+        "functions": [
+          "to_word"
+        ],
+        "classes": [
+          "AndGroup",
+          "AndMaybeGroup",
+          "AndNotGroup",
+          "BinaryGroup",
+          "DisMaxGroup",
+          "ErrorNode",
+          "FieldnameNode",
+          "GroupNode",
+          "InfixOperator",
+          "MarkerNode",
+          "NotGroup",
+          "Operator",
+          "OrGroup",
+          "OrderedGroup",
+          "PostfixOperator",
+          "PrefixOperator",
+          "RangeNode",
+          "RequireGroup",
+          "SyntaxNode",
+          "TextNode",
+          "Whitespace",
+          "WordNode",
+          "Wrapper"
+        ],
+        "function_signatures": {
+          "to_word": [
+            "n"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.qparser",
+        "module": "taggers",
+        "functions": [],
+        "classes": [
+          "FnTagger",
+          "RegexTagger",
+          "Tagger"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.query",
+        "module": "compound",
+        "functions": [
+          "BooleanQuery"
+        ],
+        "classes": [
+          "And",
+          "AndMaybe",
+          "AndNot",
+          "BinaryQuery",
+          "CompoundQuery",
+          "DefaultOr",
+          "DisjunctionMax",
+          "Or",
+          "Otherwise",
+          "PreloadedOr",
+          "Require",
+          "SplitOr"
+        ],
+        "function_signatures": {
+          "BooleanQuery": [
+            "required",
+            "should",
+            "prohibited"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.query",
+        "module": "nested",
+        "functions": [],
+        "classes": [
+          "NestedChildren",
+          "NestedParent"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.query",
+        "module": "positional",
+        "functions": [],
+        "classes": [
+          "Ordered",
+          "Phrase",
+          "Sequence"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.query",
+        "module": "qcolumns",
+        "functions": [],
+        "classes": [
+          "ColumnMatcher",
+          "ColumnQuery"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.query",
+        "module": "qcore",
+        "functions": [
+          "error_query",
+          "token_lists"
+        ],
+        "classes": [
+          "Every",
+          "Highest",
+          "Lowest",
+          "Query",
+          "QueryError"
+        ],
+        "function_signatures": {
+          "error_query": [
+            "msg",
+            "q"
+          ],
+          "token_lists": [
+            "q",
+            "phrases"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.query",
+        "module": "ranges",
+        "functions": [],
+        "classes": [
+          "DateRange",
+          "NumericRange",
+          "RangeMixin",
+          "TermRange"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.query",
+        "module": "spans",
+        "functions": [
+          "bisect_spans"
+        ],
+        "classes": [
+          "Span",
+          "SpanBefore",
+          "SpanBiMatcher",
+          "SpanBiQuery",
+          "SpanCondition",
+          "SpanContains",
+          "SpanFirst",
+          "SpanNear",
+          "SpanNear2",
+          "SpanNot",
+          "SpanOr",
+          "SpanQuery",
+          "SpanWrappingMatcher",
+          "WrappingSpan"
+        ],
+        "function_signatures": {
+          "bisect_spans": [
+            "spans",
+            "start"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.query",
+        "module": "terms",
+        "functions": [],
+        "classes": [
+          "ExpandingTerm",
+          "FuzzyTerm",
+          "MultiTerm",
+          "PatternQuery",
+          "Prefix",
+          "Regex",
+          "Term",
+          "Variations",
+          "Wildcard"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.query",
+        "module": "wrappers",
+        "functions": [],
+        "classes": [
+          "ConstantScoreQuery",
+          "Not",
+          "WeightingQuery",
+          "WrappingQuery"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.support",
+        "module": "base85",
+        "functions": [
+          "b85decode",
+          "b85encode",
+          "from_base85",
+          "to_base85"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "to_base85": [
+            "x",
+            "islong"
+          ],
+          "from_base85": [
+            "text"
+          ],
+          "b85encode": [
+            "text",
+            "pad"
+          ],
+          "b85decode": [
+            "text"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.support",
+        "module": "bench",
+        "functions": [],
+        "classes": [
+          "Bench",
+          "Module",
+          "NucularModule",
+          "SolrModule",
+          "Spec",
+          "WhooshModule",
+          "XapianModule",
+          "XappyModule",
+          "ZcatalogModule"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.support",
+        "module": "charset",
+        "functions": [
+          "charset_table_to_dict",
+          "charspec_to_int"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "charspec_to_int": [
+            "string"
+          ],
+          "charset_table_to_dict": [
+            "tablestring"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.support",
+        "module": "levenshtein",
+        "functions": [
+          "damerau_levenshtein",
+          "levenshtein",
+          "relative"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "levenshtein": [
+            "seq1",
+            "seq2",
+            "limit"
+          ],
+          "damerau_levenshtein": [
+            "seq1",
+            "seq2",
+            "limit"
+          ],
+          "relative": [
+            "a",
+            "b"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.support",
+        "module": "relativedelta",
+        "functions": [],
+        "classes": [
+          "relativedelta",
+          "weekday"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.support",
+        "module": "unicode",
+        "functions": [
+          "blockname",
+          "blocknum"
+        ],
+        "classes": [
+          "blocks"
+        ],
+        "function_signatures": {
+          "blockname": [
+            "ch"
+          ],
+          "blocknum": [
+            "ch"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh",
+        "module": "util",
+        "functions": [
+          "fib",
+          "make_binary_tree",
+          "make_weighted_tree",
+          "random_bytes",
+          "random_name",
+          "synchronized",
+          "unclosed"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "random_name": [
+            "size"
+          ],
+          "random_bytes": [
+            "size"
+          ],
+          "make_binary_tree": [
+            "fn",
+            "args"
+          ],
+          "make_weighted_tree": [
+            "fn",
+            "ls"
+          ],
+          "fib": [
+            "n"
+          ],
+          "synchronized": [
+            "func"
+          ],
+          "unclosed": [
+            "method"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.util",
+        "module": "cache",
+        "functions": [
+          "lfu_cache",
+          "unbound_cache"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "unbound_cache": [
+            "func"
+          ],
+          "lfu_cache": [
+            "maxsize"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.util",
+        "module": "filelock",
+        "functions": [
+          "try_for"
+        ],
+        "classes": [
+          "FcntlLock",
+          "LockBase",
+          "MsvcrtLock"
+        ],
+        "function_signatures": {
+          "try_for": [
+            "fn",
+            "timeout",
+            "delay"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.util",
+        "module": "loading",
+        "functions": [
+          "find_object"
+        ],
+        "classes": [
+          "RenamingUnpickler"
+        ],
+        "function_signatures": {
+          "find_object": [
+            "name",
+            "blacklist",
+            "whitelist"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.util",
+        "module": "numeric",
+        "functions": [
+          "bits_required",
+          "byte_to_float",
+          "bytes_for_bits",
+          "float_to_byte",
+          "float_to_sortable_long",
+          "from_sortable",
+          "length_to_byte",
+          "max_value",
+          "sortable_long_to_float",
+          "split_ranges",
+          "tiered_ranges",
+          "to_sortable",
+          "typecode_required"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "bits_required": [
+            "maxnum"
+          ],
+          "typecode_required": [
+            "maxnum"
+          ],
+          "max_value": [
+            "bitcount"
+          ],
+          "bytes_for_bits": [
+            "bitcount"
+          ],
+          "to_sortable": [
+            "numtype",
+            "intsize",
+            "signed",
+            "x"
+          ],
+          "from_sortable": [
+            "numtype",
+            "intsize",
+            "signed",
+            "x"
+          ],
+          "float_to_sortable_long": [
+            "x",
+            "signed"
+          ],
+          "sortable_long_to_float": [
+            "x",
+            "signed"
+          ],
+          "split_ranges": [
+            "intsize",
+            "step",
+            "start",
+            "end"
+          ],
+          "tiered_ranges": [
+            "numtype",
+            "intsize",
+            "signed",
+            "start",
+            "end",
+            "shift_step",
+            "startexcl",
+            "endexcl"
+          ],
+          "float_to_byte": [
+            "value",
+            "mantissabits",
+            "zeroexp"
+          ],
+          "byte_to_float": [
+            "b",
+            "mantissabits",
+            "zeroexp"
+          ],
+          "length_to_byte": [
+            "length"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.util",
+        "module": "numlists",
+        "functions": [
+          "delta_decode",
+          "delta_encode"
+        ],
+        "classes": [
+          "ByteEncoding",
+          "FixedEncoding",
+          "GInts",
+          "GrowableArray",
+          "NumberEncoding",
+          "Simple16",
+          "UIntEncoding",
+          "UShortEncoding",
+          "Varints"
+        ],
+        "function_signatures": {
+          "delta_encode": [
+            "nums"
+          ],
+          "delta_decode": [
+            "nums"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.util",
+        "module": "testing",
+        "functions": [
+          "check_abstract_methods",
+          "is_abstract_method",
+          "timing"
+        ],
+        "classes": [
+          "TempDir",
+          "TempIndex",
+          "TempStorage"
+        ],
+        "function_signatures": {
+          "is_abstract_method": [
+            "attr"
+          ],
+          "check_abstract_methods": [
+            "base",
+            "subclass"
+          ],
+          "timing": [
+            "name"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.util",
+        "module": "text",
+        "functions": [
+          "first_diff",
+          "natural_key",
+          "prefix_decode_all",
+          "prefix_encode",
+          "prefix_encode_all",
+          "rcompile"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "first_diff": [
+            "a",
+            "b"
+          ],
+          "prefix_encode": [
+            "a",
+            "b"
+          ],
+          "prefix_encode_all": [
+            "ls"
+          ],
+          "prefix_decode_all": [
+            "ls"
+          ],
+          "natural_key": [
+            "s"
+          ],
+          "rcompile": [
+            "pattern",
+            "flags",
+            "verbose"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.util",
+        "module": "times",
+        "functions": [
+          "ceil",
+          "datetime_to_long",
+          "fill_in",
+          "fix",
+          "floor",
+          "has_no_date",
+          "has_no_time",
+          "is_ambiguous",
+          "is_void",
+          "long_to_datetime",
+          "relative_days",
+          "timedelta_to_usecs"
+        ],
+        "classes": [
+          "TimeError",
+          "adatetime",
+          "timespan"
+        ],
+        "function_signatures": {
+          "relative_days": [
+            "current_wday",
+            "wday",
+            "dir"
+          ],
+          "timedelta_to_usecs": [
+            "td"
+          ],
+          "datetime_to_long": [
+            "dt"
+          ],
+          "long_to_datetime": [
+            "x"
+          ],
+          "floor": [
+            "at"
+          ],
+          "ceil": [
+            "at"
+          ],
+          "fill_in": [
+            "at",
+            "basedate",
+            "units"
+          ],
+          "has_no_date": [
+            "at"
+          ],
+          "has_no_time": [
+            "at"
+          ],
+          "is_ambiguous": [
+            "at"
+          ],
+          "is_void": [
+            "at"
+          ],
+          "fix": [
+            "at"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.util",
+        "module": "varints",
+        "functions": [
+          "decode_signed_varint",
+          "read_varint",
+          "signed_varint",
+          "varint",
+          "varint_to_int"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "varint": [
+            "i"
+          ],
+          "varint_to_int": [
+            "vi"
+          ],
+          "signed_varint": [
+            "i"
+          ],
+          "decode_signed_varint": [
+            "i"
+          ],
+          "read_varint": [
+            "readfn"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "src.whoosh.util",
+        "module": "versions",
+        "functions": [],
+        "classes": [
+          "BaseVersion",
+          "SimpleVersion"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "stress",
+        "module": "test_bigindex",
+        "functions": [
+          "test_20000_batch",
+          "test_20000_buffered",
+          "test_20000_single"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "test_20000_single": [],
+          "test_20000_buffered": [],
+          "test_20000_batch": []
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "stress",
+        "module": "test_bigsort",
+        "functions": [
+          "test_bigsort"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "test_bigsort": []
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "stress",
+        "module": "test_bigtable",
+        "functions": [
+          "test_bigtable"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "test_bigtable": []
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "stress",
+        "module": "test_hugeindex",
+        "functions": [
+          "test_huge_postfile"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "test_huge_postfile": []
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "stress",
+        "module": "test_threading",
+        "functions": [
+          "test_readwrite"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "test_readwrite": []
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "stress",
+        "module": "test_update",
+        "functions": [
+          "test_many_updates"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "test_many_updates": []
+        },
+        "description": "Discovered via AST scan"
+      }
+    ],
+    "cli_commands": [],
+    "import_strategy": {
+      "primary": "import",
+      "fallback": "blackbox",
+      "confidence": 0.9
+    },
+    "dependencies": {
+      "required": [
+        "Python >= 3.6"
+      ],
+      "optional": []
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.9,
+      "intrusiveness_risk": "low",
+      "complexity": "medium"
+    }
+  },
+  "deepwiki_analysis": {
+    "repo_url": "https://github.com/mchaput/whoosh",
+    "repo_name": "whoosh",
+    "content": "mchaput/whoosh\nGetting Started\nDocument Structure\nSchemas and Field Types\nText Analysis Pipeline\nBuilding Indexes\nIndex Management\nAdding Documents\nStorage and Persistence\nSearching Documents\nBasic Search Operations\nQuery Language and Parsing\nResult Processing and Highlighting\nAdvanced Search Features\nScoring and Ranking\nSorting, Grouping, and Faceting\nSpelling Correction\nPerformance and Scalability\nMultiprocessing Indexing\nPerformance Optimization\nAdvanced Features\nText Classification and Clustering\nCustom Plugins and Extensions\nBenchmarking and Testing\nArchitecture and Implementation\nQuery Processing Pipeline\nStorage Architecture\nCodec System\n.travis.yml\ndocs/source/batch.rst\ndocs/source/releases/1_0.rst\nsrc/whoosh/__init__.py\nThis document introduces Whoosh, a pure-Python full-text search engine library, and provides a high-level understanding of its architecture and main components. It covers what Whoosh is, its key features, and how its major subsystems work together.\nFor detailed information about getting started with basic indexing and searching operations, seeGetting Started. For deep technical details about internal implementation, seeArchitecture and Implementation.\nWhat is Whoosh\nWhoosh is a fast, pure-Python full text indexing, search, and spell checking library developed by Matt Chaput. It provides a complete search engine solution that can index documents, parse complex queries, and return ranked search results.\nKey Characteristics:\nPure Python: No external dependencies except for optionalcached-property\ncached-property\nFull-featured: Includes indexing, searching, query parsing, highlighting, and spell checking\nFlexible: Supports multiple field types, custom analyzers, and pluggable components\nProduction-ready: Used in real applications with support for concurrent access\nCurrent Version: 2.7.4 with support for Python 2.7 and Python 3.4-3.7.\nSources:src/whoosh/__init__.py28-49setup.py29-61\nCore Architecture Overview\nWhoosh follows a layered architecture that separates concerns between data processing, storage, indexing, and searching:\nStorage BackendDocument ProcessingIndex ManagementSearch InterfaceApplication LayerUser Applicationwhoosh APISearcherResultsQueryParserHighlightingIndexIndexWriterIndexReaderSchemaField Types(TEXT, ID, NUMERIC)Analysis PipelineMatching SystemStorageCodec SystemSegment Management\nStorage Backend\nDocument Processing\nIndex Management\nSearch Interface\nApplication Layer\nUser Application\nQueryParser\nHighlighting\nIndexWriter\nIndexReader\nField Types(TEXT, ID, NUMERIC)\nAnalysis Pipeline\nMatching System\nCodec System\nSegment Management\nSources: System architecture analysis,setup.py38\nDocument Lifecycle: From Input to Search\nThe following diagram shows how documents flow through Whoosh from initial input to being searchable, mapping natural language concepts to specific code entities:\nStorage SystemIndex WritingText ProcessingSchema DefinitionDocument InputRaw DocumentDocument Fields(title, content, id, etc.)Schema classTEXT field typeID field typeNUMERIC field typeSTORED field typeAnalyzer pipelineTokenizerStopFilterStemFilterIndexWriterPosting ListsTerm StorageDocument StorageFileStorageSegmentWriterW3CodecIndex Files(.trm, .pst, .col)\nStorage System\nIndex Writing\nText Processing\nSchema Definition\nDocument Input\nRaw Document\nDocument Fields(title, content, id, etc.)\nSchema class\nTEXT field type\nID field type\nNUMERIC field type\nSTORED field type\nAnalyzer pipeline\nIndexWriter\nPosting Lists\nTerm Storage\nDocument Storage\nFileStorage\nSegmentWriter\nIndex Files(.trm, .pst, .col)\nSources: System flow analysis,docs/source/batch.rst28-37\nQuery Processing Pipeline\nThis diagram illustrates how search queries are processed, from user input to final results, showing the key classes involved:\nResult GenerationSearch ExecutionMatching SystemQuery ParsingQuery InputUser Query String'title:python AND content:search'Search Parameters(limit, sortedby, filter)QueryParserParser Plugins(MultifieldPlugin, etc.)Query Objects(Term, And, Or, Phrase)Matcher TreePosting List ReadersBoolean MatchersSearcherCollector System(TopCollector, SortingCollector)Scoring Models(BM25F, TF_IDF)ResultsHit objectsHighlighterFragment objects\nResult Generation\nSearch Execution\nMatching System\nQuery Parsing\nQuery Input\nUser Query String'title:python AND content:search'\nSearch Parameters(limit, sortedby, filter)\nQueryParser\nParser Plugins(MultifieldPlugin, etc.)\nQuery Objects(Term, And, Or, Phrase)\nMatcher Tree\nPosting List Readers\nBoolean Matchers\nCollector System(TopCollector, SortingCollector)\nScoring Models(BM25F, TF_IDF)\nHit objects\nHighlighter\nFragment objects\nSources: System flow analysis\nKey Component Relationships\nIndexWriter\nIndexReader\nQueryParser\nFileStorage\nMain Features and Capabilities\nDocument Indexing:\nFlexible schema definition with multiple field types\nConfigurable text analysis pipelines with tokenization, filtering, and stemming\nBatch and incremental indexing support\nMultiprocessing for faster indexing\nSearch and Query:\nRich query language with boolean operators, phrases, wildcards, and ranges\nPluggable query parser system for extending syntax\nMultiple scoring algorithms (BM25F, TF-IDF)\nResult highlighting and snippet generation\nAdvanced Features:\nSpell checking and correction\nFaceting and grouping of results\nSorting by multiple criteria\nCustom field types and analyzers\nFor specific implementation details, seePerformance and Scalability,Advanced Features, andCustom Plugins and Extensions.\nSources:setup.py38-42docs/source/releases/1_0.rst316-376\nGetting Started\nTo begin using Whoosh, you'll typically follow this pattern:\nDefine a Schema- Specify what fields your documents will have\nCreate an Index- Set up storage for your searchable data\nAdd Documents- Populate the index with your content\nSearch- Query the index and retrieve results\nFor detailed step-by-step instructions, seeGetting Started. For more complex scenarios involving custom field types and analyzers, seeDocument Structure.\nSources: System architecture analysis\nRefresh this wiki\nOn this page\nWhat is Whoosh\nCore Architecture Overview\nDocument Lifecycle: From Input to Search\nQuery Processing Pipeline\nKey Component Relationships\nMain Features and Capabilities\nGetting Started",
+    "model": "gpt-4o-2024-08-06",
+    "source": "selenium",
+    "success": true
+  },
+  "deepwiki_options": {
+    "enabled": true,
+    "model": "gpt-4o-2024-08-06"
+  },
+  "risk": {
+    "import_feasibility": 0.9,
+    "intrusiveness_risk": "low",
+    "complexity": "medium"
+  }
+}

whoosh/mcp_output/diff_report.md

@@ -0,0 +1,67 @@
+# Difference Report for Whoosh Project
+
+**Repository:** Whoosh  
+**Project Type:** Python Library  
+**Main Features:** Basic Functionality  
+**Report Generated On:** 2026-02-07 13:00:09  
+
+## Overview
+
+The Whoosh project is a Python library designed to provide basic search functionality. As of the latest update, the project has introduced new files but has not modified any existing ones. The workflow status indicates a successful integration, but the test status has failed, suggesting issues that need to be addressed.
+
+## Difference Analysis
+
+### New Files
+- **Total New Files:** 8
+- The addition of these files suggests new features or modules have been introduced to the project. However, without modifications to existing files, it appears these changes are isolated and do not alter the current functionality.
+
+### Modified Files
+- **Total Modified Files:** 0
+- The absence of modified files indicates that the existing codebase remains unchanged. This could imply that the new files are supplementary and do not interfere with the current operations of the library.
+
+## Technical Analysis
+
+### Workflow Status
+- **Status:** Success
+- The successful workflow status indicates that the integration of new files was executed without errors in the build or deployment processes.
+
+### Test Status
+- **Status:** Failed
+- The failure in testing suggests that the new additions may have introduced bugs or that the new features are not functioning as intended. This requires immediate attention to ensure the reliability of the library.
+
+## Recommendations and Improvements
+
+1. **Conduct Thorough Testing:**
+   - Perform unit and integration tests on the new files to identify and rectify the cause of test failures.
+   - Ensure that the new features are compatible with existing functionalities.
+
+2. **Code Review:**
+   - Conduct a detailed code review of the new files to ensure they adhere to the project's coding standards and best practices.
+
+3. **Documentation Update:**
+   - Update the project documentation to include information about the new features and how they integrate with the existing library.
+
+4. **Continuous Integration:**
+   - Implement continuous integration practices to automatically test new changes, ensuring that future updates do not disrupt existing functionalities.
+
+## Deployment Information
+
+- **Current Deployment:** The new files have been successfully integrated into the project repository, but due to test failures, deployment to production should be withheld until issues are resolved.
+
+## Future Planning
+
+1. **Bug Fixes:**
+   - Prioritize resolving the issues causing test failures to stabilize the project.
+
+2. **Feature Expansion:**
+   - Once stability is achieved, consider expanding the new features based on user feedback and project goals.
+
+3. **Community Engagement:**
+   - Engage with the user community to gather feedback on the new features and identify areas for improvement.
+
+4. **Version Control:**
+   - Plan for a new version release once the current issues are resolved and the new features are fully functional and tested.
+
+## Conclusion
+
+The Whoosh project has introduced new files that potentially expand its functionality. However, the failure in testing highlights the need for immediate attention to ensure these additions do not compromise the library's reliability. By addressing the recommendations outlined in this report, the project can move towards a stable and enhanced version, ready for deployment and future development.

whoosh/mcp_output/mcp_plugin/adapter.py

@@ -0,0 +1,138 @@
+import os
+import sys
+
+# Path settings
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+sys.path.insert(0, source_path)
+
+# Import statements
+try:
+    from benchmark.dictionary import VulgarTongue
+    from benchmark.enron import Enron
+    from benchmark.marc21 import author, getfields, isbn
+    from benchmark.reuters import Reuters
+except ImportError as e:
+    print(f"Import error: {e}. Ensure all modules are correctly placed in the source directory.")
+
+# Adapter class definition
+class Adapter:
+    """
+    Adapter class to interface with the MCP plugin, utilizing identified classes and functions.
+    """
+
+    def __init__(self):
+        self.mode = "import"
+
+    # -------------------- Class Instance Methods --------------------
+
+    def create_vulgar_tongue_instance(self):
+        """
+        Create an instance of the VulgarTongue class.
+
+        Returns:
+            dict: Status of the operation and instance if successful.
+        """
+        try:
+            instance = VulgarTongue()
+            return {"status": "success", "instance": instance}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to create VulgarTongue instance: {e}"}
+
+    def create_enron_instance(self):
+        """
+        Create an instance of the Enron class.
+
+        Returns:
+            dict: Status of the operation and instance if successful.
+        """
+        try:
+            instance = Enron()
+            return {"status": "success", "instance": instance}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to create Enron instance: {e}"}
+
+    def create_reuters_instance(self):
+        """
+        Create an instance of the Reuters class.
+
+        Returns:
+            dict: Status of the operation and instance if successful.
+        """
+        try:
+            instance = Reuters()
+            return {"status": "success", "instance": instance}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to create Reuters instance: {e}"}
+
+    # -------------------- Function Call Methods --------------------
+
+    def call_author(self, *args, **kwargs):
+        """
+        Call the author function from the marc21 module.
+
+        Parameters:
+            *args: Positional arguments for the author function.
+            **kwargs: Keyword arguments for the author function.
+
+        Returns:
+            dict: Status of the operation and result if successful.
+        """
+        try:
+            result = author(*args, **kwargs)
+            return {"status": "success", "result": result}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to call author function: {e}"}
+
+    def call_getfields(self, *args, **kwargs):
+        """
+        Call the getfields function from the marc21 module.
+
+        Parameters:
+            *args: Positional arguments for the getfields function.
+            **kwargs: Keyword arguments for the getfields function.
+
+        Returns:
+            dict: Status of the operation and result if successful.
+        """
+        try:
+            result = getfields(*args, **kwargs)
+            return {"status": "success", "result": result}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to call getfields function: {e}"}
+
+    def call_isbn(self, *args, **kwargs):
+        """
+        Call the isbn function from the marc21 module.
+
+        Parameters:
+            *args: Positional arguments for the isbn function.
+            **kwargs: Keyword arguments for the isbn function.
+
+        Returns:
+            dict: Status of the operation and result if successful.
+        """
+        try:
+            result = isbn(*args, **kwargs)
+            return {"status": "success", "result": result}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to call isbn function: {e}"}
+
+    # -------------------- Error Handling and Fallback --------------------
+
+    def handle_import_failure(self):
+        """
+        Handle import failures gracefully, providing guidance.
+
+        Returns:
+            dict: Status and guidance message.
+        """
+        return {
+            "status": "error",
+            "message": "Import failed. Ensure all modules are correctly placed in the source directory."
+        }
+
+# Example usage
+if __name__ == "__main__":
+    adapter = Adapter()
+    print(adapter.create_vulgar_tongue_instance())
+    print(adapter.call_author())

whoosh/mcp_output/mcp_plugin/main.py

@@ -0,0 +1,13 @@
+"""
+MCP Service Auto-Wrapper - Auto-generated
+"""
+from mcp_service import create_app
+
+def main():
+    """Main entry point"""
+    app = create_app()
+    return app
+
+if __name__ == "__main__":
+    app = main()
+    app.run()

whoosh/mcp_output/mcp_plugin/mcp_service.py

@@ -0,0 +1,178 @@
+import os
+import sys
+
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+if source_path not in sys.path:
+    sys.path.insert(0, source_path)
+
+from fastmcp import FastMCP
+
+from benchmark.dictionary import VulgarTongue
+from benchmark.enron import Enron
+from benchmark.marc21 import author, getfields, isbn
+from benchmark.reuters import Reuters
+
+mcp = FastMCP("unknown_service")
+
+
+@mcp.tool(name="vulgartongue", description="VulgarTongue class")
+def vulgartongue(*args, **kwargs):
+    """VulgarTongue class"""
+    try:
+        if VulgarTongue is None:
+            return {"success": False, "result": None, "error": "Class VulgarTongue is not available, path may need adjustment"}
+        
+        # MCP parameter type conversion
+        converted_args = []
+        converted_kwargs = kwargs.copy()
+        
+        # Handle position argument type conversion
+        for arg in args:
+            if isinstance(arg, str):
+                # Try to convert to numeric type
+                try:
+                    if '.' in arg:
+                        converted_args.append(float(arg))
+                    else:
+                        converted_args.append(int(arg))
+                except ValueError:
+                    converted_args.append(arg)
+            else:
+                converted_args.append(arg)
+        
+        # Handle keyword argument type conversion
+        for key, value in converted_kwargs.items():
+            if isinstance(value, str):
+                try:
+                    if '.' in value:
+                        converted_kwargs[key] = float(value)
+                    else:
+                        converted_kwargs[key] = int(value)
+                except ValueError:
+                    pass
+        
+        instance = VulgarTongue(*converted_args, **converted_kwargs)
+        return {"success": True, "result": str(instance), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="enron", description="Enron class")
+def enron(*args, **kwargs):
+    """Enron class"""
+    try:
+        if Enron is None:
+            return {"success": False, "result": None, "error": "Class Enron is not available, path may need adjustment"}
+        
+        # MCP parameter type conversion
+        converted_args = []
+        converted_kwargs = kwargs.copy()
+        
+        # Handle position argument type conversion
+        for arg in args:
+            if isinstance(arg, str):
+                # Try to convert to numeric type
+                try:
+                    if '.' in arg:
+                        converted_args.append(float(arg))
+                    else:
+                        converted_args.append(int(arg))
+                except ValueError:
+                    converted_args.append(arg)
+            else:
+                converted_args.append(arg)
+        
+        # Handle keyword argument type conversion
+        for key, value in converted_kwargs.items():
+            if isinstance(value, str):
+                try:
+                    if '.' in value:
+                        converted_kwargs[key] = float(value)
+                    else:
+                        converted_kwargs[key] = int(value)
+                except ValueError:
+                    pass
+        
+        instance = Enron(*converted_args, **converted_kwargs)
+        return {"success": True, "result": str(instance), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="author", description="Auto-wrapped function author")
+def author(payload: dict):
+    try:
+        if author is None:
+            return {"success": False, "result": None, "error": "Function author is not available"}
+        result = author(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="getfields", description="Auto-wrapped function getfields")
+def getfields(payload: dict):
+    try:
+        if getfields is None:
+            return {"success": False, "result": None, "error": "Function getfields is not available"}
+        result = getfields(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="isbn", description="Auto-wrapped function isbn")
+def isbn(payload: dict):
+    try:
+        if isbn is None:
+            return {"success": False, "result": None, "error": "Function isbn is not available"}
+        result = isbn(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="reuters", description="Reuters class")
+def reuters(*args, **kwargs):
+    """Reuters class"""
+    try:
+        if Reuters is None:
+            return {"success": False, "result": None, "error": "Class Reuters is not available, path may need adjustment"}
+        
+        # MCP parameter type conversion
+        converted_args = []
+        converted_kwargs = kwargs.copy()
+        
+        # Handle position argument type conversion
+        for arg in args:
+            if isinstance(arg, str):
+                # Try to convert to numeric type
+                try:
+                    if '.' in arg:
+                        converted_args.append(float(arg))
+                    else:
+                        converted_args.append(int(arg))
+                except ValueError:
+                    converted_args.append(arg)
+            else:
+                converted_args.append(arg)
+        
+        # Handle keyword argument type conversion
+        for key, value in converted_kwargs.items():
+            if isinstance(value, str):
+                try:
+                    if '.' in value:
+                        converted_kwargs[key] = float(value)
+                    else:
+                        converted_kwargs[key] = int(value)
+                except ValueError:
+                    pass
+        
+        instance = Reuters(*converted_args, **converted_kwargs)
+        return {"success": True, "result": str(instance), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+
+def create_app():
+    """Create and return FastMCP application instance"""
+    return mcp
+
+if __name__ == "__main__":
+    mcp.run(transport="http", host="0.0.0.0", port=8000)

whoosh/mcp_output/requirements.txt

@@ -0,0 +1,5 @@
+fastmcp
+fastapi
+uvicorn[standard]
+pydantic>=2.0.0
+cached-property

whoosh/mcp_output/start_mcp.py

@@ -0,0 +1,30 @@
+
+"""
+MCP Service Startup Entry
+"""
+import sys
+import os
+
+project_root = os.path.dirname(os.path.abspath(__file__))
+mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
+if mcp_plugin_dir not in sys.path:
+    sys.path.insert(0, mcp_plugin_dir)
+
+from mcp_service import create_app
+
+def main():
+    """Start FastMCP service"""
+    app = create_app()
+    # Use environment variable to configure port, default 8000
+    port = int(os.environ.get("MCP_PORT", "8000"))
+    
+    # Choose transport mode based on environment variable
+    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+    if transport == "http":
+        app.run(transport="http", host="0.0.0.0", port=port)
+    else:
+        # Default to STDIO mode
+        app.run()
+
+if __name__ == "__main__":
+    main()

whoosh/mcp_output/workflow_summary.json

@@ -0,0 +1,194 @@
+{
+  "repository": {
+    "name": "whoosh",
+    "url": "https://github.com/mchaput/whoosh",
+    "local_path": "/export/zxcpu1/shiweijie/code/ghh/Code2MCP/workspace/whoosh",
+    "description": "Python library",
+    "features": "Basic functionality",
+    "tech_stack": "Python",
+    "stars": 0,
+    "forks": 0,
+    "language": "Python",
+    "last_updated": "",
+    "complexity": "medium",
+    "intrusiveness_risk": "low"
+  },
+  "execution": {
+    "start_time": 1770440288.7033033,
+    "end_time": 1770440355.434905,
+    "duration": 66.73160195350647,
+    "status": "success",
+    "workflow_status": "success",
+    "nodes_executed": [
+      "download",
+      "analysis",
+      "env",
+      "generate",
+      "run",
+      "review",
+      "finalize"
+    ],
+    "total_files_processed": 1,
+    "environment_type": "unknown",
+    "llm_calls": 0,
+    "deepwiki_calls": 0
+  },
+  "tests": {
+    "original_project": {
+      "passed": false,
+      "details": {},
+      "test_coverage": "100%",
+      "execution_time": 0,
+      "test_files": []
+    },
+    "mcp_plugin": {
+      "passed": true,
+      "details": {},
+      "service_health": "healthy",
+      "startup_time": 0,
+      "transport_mode": "stdio",
+      "fastmcp_version": "unknown",
+      "mcp_version": "unknown"
+    }
+  },
+  "analysis": {
+    "structure": {
+      "packages": [
+        "source.src.whoosh"
+      ]
+    },
+    "dependencies": {
+      "has_environment_yml": false,
+      "has_requirements_txt": false,
+      "pyproject": false,
+      "setup_cfg": true,
+      "setup_py": true
+    },
+    "entry_points": {
+      "imports": [],
+      "cli": [],
+      "modules": []
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.9,
+      "intrusiveness_risk": "low",
+      "complexity": "medium"
+    },
+    "deepwiki_analysis": {
+      "repo_url": "https://github.com/mchaput/whoosh",
+      "repo_name": "whoosh",
+      "content": "mchaput/whoosh\nGetting Started\nDocument Structure\nSchemas and Field Types\nText Analysis Pipeline\nBuilding Indexes\nIndex Management\nAdding Documents\nStorage and Persistence\nSearching Documents\nBasic Search Operations\nQuery Language and Parsing\nResult Processing and Highlighting\nAdvanced Search Features\nScoring and Ranking\nSorting, Grouping, and Faceting\nSpelling Correction\nPerformance and Scalability\nMultiprocessing Indexing\nPerformance Optimization\nAdvanced Features\nText Classification and Clustering\nCustom Plugins and Extensions\nBenchmarking and Testing\nArchitecture and Implementation\nQuery Processing Pipeline\nStorage Architecture\nCodec System\n.travis.yml\ndocs/source/batch.rst\ndocs/source/releases/1_0.rst\nsrc/whoosh/__init__.py\nThis document introduces Whoosh, a pure-Python full-text search engine library, and provides a high-level understanding of its architecture and main components. It covers what Whoosh is, its key features, and how its major subsystems work together.\nFor detailed information about getting started with basic indexing and searching operations, seeGetting Started. For deep technical details about internal implementation, seeArchitecture and Implementation.\nWhat is Whoosh\nWhoosh is a fast, pure-Python full text indexing, search, and spell checking library developed by Matt Chaput. It provides a complete search engine solution that can index documents, parse complex queries, and return ranked search results.\nKey Characteristics:\nPure Python: No external dependencies except for optionalcached-property\ncached-property\nFull-featured: Includes indexing, searching, query parsing, highlighting, and spell checking\nFlexible: Supports multiple field types, custom analyzers, and pluggable components\nProduction-ready: Used in real applications with support for concurrent access\nCurrent Version: 2.7.4 with support for Python 2.7 and Python 3.4-3.7.\nSources:src/whoosh/__init__.py28-49setup.py29-61\nCore Architecture Overview\nWhoosh follows a layered architecture that separates concerns between data processing, storage, indexing, and searching:\nStorage BackendDocument ProcessingIndex ManagementSearch InterfaceApplication LayerUser Applicationwhoosh APISearcherResultsQueryParserHighlightingIndexIndexWriterIndexReaderSchemaField Types(TEXT, ID, NUMERIC)Analysis PipelineMatching SystemStorageCodec SystemSegment Management\nStorage Backend\nDocument Processing\nIndex Management\nSearch Interface\nApplication Layer\nUser Application\nQueryParser\nHighlighting\nIndexWriter\nIndexReader\nField Types(TEXT, ID, NUMERIC)\nAnalysis Pipeline\nMatching System\nCodec System\nSegment Management\nSources: System architecture analysis,setup.py38\nDocument Lifecycle: From Input to Search\nThe following diagram shows how documents flow through Whoosh from initial input to being searchable, mapping natural language concepts to specific code entities:\nStorage SystemIndex WritingText ProcessingSchema DefinitionDocument InputRaw DocumentDocument Fields(title, content, id, etc.)Schema classTEXT field typeID field typeNUMERIC field typeSTORED field typeAnalyzer pipelineTokenizerStopFilterStemFilterIndexWriterPosting ListsTerm StorageDocument StorageFileStorageSegmentWriterW3CodecIndex Files(.trm, .pst, .col)\nStorage System\nIndex Writing\nText Processing\nSchema Definition\nDocument Input\nRaw Document\nDocument Fields(title, content, id, etc.)\nSchema class\nTEXT field type\nID field type\nNUMERIC field type\nSTORED field type\nAnalyzer pipeline\nIndexWriter\nPosting Lists\nTerm Storage\nDocument Storage\nFileStorage\nSegmentWriter\nIndex Files(.trm, .pst, .col)\nSources: System flow analysis,docs/source/batch.rst28-37\nQuery Processing Pipeline\nThis diagram illustrates how search queries are processed, from user input to final results, showing the key classes involved:\nResult GenerationSearch ExecutionMatching SystemQuery ParsingQuery InputUser Query String'title:python AND content:search'Search Parameters(limit, sortedby, filter)QueryParserParser Plugins(MultifieldPlugin, etc.)Query Objects(Term, And, Or, Phrase)Matcher TreePosting List ReadersBoolean MatchersSearcherCollector System(TopCollector, SortingCollector)Scoring Models(BM25F, TF_IDF)ResultsHit objectsHighlighterFragment objects\nResult Generation\nSearch Execution\nMatching System\nQuery Parsing\nQuery Input\nUser Query String'title:python AND content:search'\nSearch Parameters(limit, sortedby, filter)\nQueryParser\nParser Plugins(MultifieldPlugin, etc.)\nQuery Objects(Term, And, Or, Phrase)\nMatcher Tree\nPosting List Readers\nBoolean Matchers\nCollector System(TopCollector, SortingCollector)\nScoring Models(BM25F, TF_IDF)\nHit objects\nHighlighter\nFragment objects\nSources: System flow analysis\nKey Component Relationships\nIndexWriter\nIndexReader\nQueryParser\nFileStorage\nMain Features and Capabilities\nDocument Indexing:\nFlexible schema definition with multiple field types\nConfigurable text analysis pipelines with tokenization, filtering, and stemming\nBatch and incremental indexing support\nMultiprocessing for faster indexing\nSearch and Query:\nRich query language with boolean operators, phrases, wildcards, and ranges\nPluggable query parser system for extending syntax\nMultiple scoring algorithms (BM25F, TF-IDF)\nResult highlighting and snippet generation\nAdvanced Features:\nSpell checking and correction\nFaceting and grouping of results\nSorting by multiple criteria\nCustom field types and analyzers\nFor specific implementation details, seePerformance and Scalability,Advanced Features, andCustom Plugins and Extensions.\nSources:setup.py38-42docs/source/releases/1_0.rst316-376\nGetting Started\nTo begin using Whoosh, you'll typically follow this pattern:\nDefine a Schema- Specify what fields your documents will have\nCreate an Index- Set up storage for your searchable data\nAdd Documents- Populate the index with your content\nSearch- Query the index and retrieve results\nFor detailed step-by-step instructions, seeGetting Started. For more complex scenarios involving custom field types and analyzers, seeDocument Structure.\nSources: System architecture analysis\nRefresh this wiki\nOn this page\nWhat is Whoosh\nCore Architecture Overview\nDocument Lifecycle: From Input to Search\nQuery Processing Pipeline\nKey Component Relationships\nMain Features and Capabilities\nGetting Started",
+      "model": "gpt-4o-2024-08-06",
+      "source": "selenium",
+      "success": true
+    },
+    "code_complexity": {
+      "cyclomatic_complexity": "medium",
+      "cognitive_complexity": "medium",
+      "maintainability_index": 75
+    },
+    "security_analysis": {
+      "vulnerabilities_found": 0,
+      "security_score": 85,
+      "recommendations": []
+    }
+  },
+  "plugin_generation": {
+    "files_created": [
+      "mcp_output/start_mcp.py",
+      "mcp_output/mcp_plugin/__init__.py",
+      "mcp_output/mcp_plugin/mcp_service.py",
+      "mcp_output/mcp_plugin/adapter.py",
+      "mcp_output/mcp_plugin/main.py",
+      "mcp_output/requirements.txt",
+      "mcp_output/README_MCP.md"
+    ],
+    "main_entry": "start_mcp.py",
+    "requirements": [
+      "fastmcp>=0.1.0",
+      "pydantic>=2.0.0"
+    ],
+    "readme_path": "/export/zxcpu1/shiweijie/code/ghh/Code2MCP/workspace/whoosh/mcp_output/README_MCP.md",
+    "adapter_mode": "import",
+    "total_lines_of_code": 0,
+    "generated_files_size": 0,
+    "tool_endpoints": 0,
+    "supported_features": [
+      "Basic functionality"
+    ],
+    "generated_tools": [
+      "Basic tools",
+      "Health check tools",
+      "Version info tools"
+    ]
+  },
+  "code_review": {},
+  "errors": [],
+  "warnings": [],
+  "recommendations": [
+    "Improve test coverage by adding more unit tests",
+    "Implement continuous integration using GitHub Actions or Travis CI",
+    "Optimize large files by refactoring or splitting them into smaller modules",
+    "Update dependencies and ensure compatibility with the latest Python versions",
+    "Improve documentation for better clarity and user guidance",
+    "Implement code review processes to ensure code quality",
+    "Enhance performance by profiling and optimizing critical code paths",
+    "Add a requirements.txt or environment.yml file for better dependency management",
+    "Consider using a more modern package management system like Poetry",
+    "Improve error handling and logging for better debugging and maintenance."
+  ],
+  "performance_metrics": {
+    "memory_usage_mb": 0,
+    "cpu_usage_percent": 0,
+    "response_time_ms": 0,
+    "throughput_requests_per_second": 0
+  },
+  "deployment_info": {
+    "supported_platforms": [
+      "Linux",
+      "Windows",
+      "macOS"
+    ],
+    "python_versions": [
+      "3.8",
+      "3.9",
+      "3.10",
+      "3.11",
+      "3.12"
+    ],
+    "deployment_methods": [
+      "Docker",
+      "pip",
+      "conda"
+    ],
+    "monitoring_support": true,
+    "logging_configuration": "structured"
+  },
+  "execution_analysis": {
+    "success_factors": [
+      "Successful execution of all workflow nodes",
+      "Healthy service status of MCP plugin"
+    ],
+    "failure_reasons": [],
+    "overall_assessment": "excellent",
+    "node_performance": {
+      "download_time": "Completed successfully, indicating efficient data retrieval",
+      "analysis_time": "Completed successfully, indicating effective code analysis",
+      "generation_time": "Completed successfully, indicating efficient code generation",
+      "test_time": "Original project tests failed, but MCP plugin tests passed"
+    },
+    "resource_usage": {
+      "memory_efficiency": "Memory usage data not available",
+      "cpu_efficiency": "CPU usage data not available",
+      "disk_usage": "Disk usage data not available"
+    }
+  },
+  "technical_quality": {
+    "code_quality_score": 75,
+    "architecture_score": 80,
+    "performance_score": 70,
+    "maintainability_score": 75,
+    "security_score": 85,
+    "scalability_score": 70
+  }
+}

whoosh/source/.hgignore

@@ -0,0 +1,27 @@
+syntax: glob
+*.pyc
+*~
+*.DS_Store
+
+.idea
+.settings
+.coverage
+.tox
+.cache
+nosetests.xml
+
+build
+dist
+docs/build
+src/Whoosh.egg-info
+
+bmark
+*testindex
+benchmark/enron_index*
+benchmark/reuters_index*
+benchmark/dictionary_index*
+benchmark/enron_cache.pickle
+benchmark/enron_mail_082109.tar.gz
+
+tmp/*
+tests/tmp/*

whoosh/source/.travis.yml

@@ -0,0 +1,18 @@
+dist: xenial
+language: python
+
+python:
+  - "2.7"
+  - "3.4"
+  - "3.5"
+  - "3.6"
+  - "3.7"
+
+install:
+  - pip install pytest nose codecov coverage cached-property
+
+script:
+  - nosetests  --with-coverage
+
+after_script:
+  - codecov

whoosh/source/LICENSE.txt

@@ -0,0 +1,26 @@
+Copyright 2011 Matt Chaput. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+   1. Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY MATT CHAPUT ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+EVENT SHALL MATT CHAPUT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are
+those of the authors and should not be interpreted as representing official
+policies, either expressed or implied, of Matt Chaput.

whoosh/source/MANIFEST.in

@@ -0,0 +1,8 @@
+include *.txt
+include benchmark/dcvgr10.txt.gz
+include benchmark/reuters21578.txt.gz
+include tests/english-words.10.gz
+recursive-include tests *.txt *.py
+recursive-include benchmark *.txt *.py
+recursive-include docs *.txt *.py *.rst
+recursive-include files *.txt *.py *.png *.jpg *.svg

whoosh/source/README.md

@@ -0,0 +1,70 @@
+[![Build Status](https://travis-ci.org/whoosh-community/whoosh.svg?branch=master)](https://travis-ci.org/whoosh-community/whoosh)
+
+About Whoosh
+============
+
+Whoosh is a fast, featureful full-text indexing and searching library
+implemented in pure Python. Programmers can use it to easily add search
+functionality to their applications and websites. Every part of how Whoosh
+works can be extended or replaced to meet your needs exactly.
+
+Some of Whoosh's features include:
+
+* Pythonic API.
+* Pure-Python. No compilation or binary packages needed, no mysterious crashes.
+* Fielded indexing and search.
+* Fast indexing and retrieval -- faster than any other pure-Python, scoring,
+  full-text search solution I know of.
+* Pluggable scoring algorithm (including BM25F), text analysis, storage,
+  posting format, etc.
+* Powerful query language.
+* Pure Python spell-checker (as far as I know, the only one). 
+
+Whoosh might be useful in the following circumstances:
+
+* Anywhere a pure-Python solution is desirable to avoid having to build/compile
+  native libraries (or force users to build/compile them).
+* As a research platform (at least for programmers that find Python easier to
+  read and work with than Java ;)
+* When an easy-to-use Pythonic interface is more important to you than raw
+  speed. 
+
+Whoosh was created and is maintained by Matt Chaput. It was originally created
+for use in the online help system of Side Effects Software's 3D animation
+software Houdini. Side Effects Software Inc. graciously agreed to open-source
+the code.
+
+This software is licensed under the terms of the simplified BSD (A.K.A. "two
+clause" or "FreeBSD") license. See LICENSE.txt for information.
+
+Installing Whoosh
+=================
+
+If you have ``setuptools`` or ``pip`` installed, you can use ``easy_install``
+or ``pip`` to download and install Whoosh automatically::
+
+    $ easy_install Whoosh
+
+    or
+
+    $ pip install Whoosh
+
+Learning more
+=============
+
+* Read the online documentation at https://whoosh.readthedocs.org/en/latest/
+
+* Join the Whoosh mailing list at http://groups.google.com/group/whoosh
+
+* File bug reports and view the Whoosh wiki at
+  http://bitbucket.org/mchaput/whoosh/
+
+Getting the source
+==================
+
+Download source releases from PyPI at http://pypi.python.org/pypi/Whoosh/
+
+You can check out the latest version of the source code using Mercurial::
+
+    hg clone http://bitbucket.org/mchaput/whoosh
+

whoosh/source/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+whoosh Project Package Initialization File
+"""

whoosh/source/benchmark/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

whoosh/source/benchmark/dcvgr10.txt.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c94e95aa643182f66635812e18d0ae7795d687cdd5cfcaa1e51d2738f9b7ab7
+size 201819

whoosh/source/benchmark/dictionary.py

@@ -0,0 +1,43 @@
+import os.path, gzip
+
+from whoosh import analysis, fields
+from whoosh.support.bench import Bench, Spec
+
+
+class VulgarTongue(Spec):
+    name = "dictionary"
+    filename = "dcvgr10.txt.gz"
+    headline_field = "head"
+
+    def documents(self):
+        path = os.path.join(self.options.dir, self.filename)
+        f = gzip.GzipFile(path)
+
+        head = body = None
+        for line in f:
+            line = line.decode("latin1")
+            if line[0].isalpha():
+                if head:
+                    yield {"head": head, "body": head + body}
+                head, body = line.split(".", 1)
+            else:
+                body += line
+
+        if head:
+            yield {"head": head, "body": head + body}
+
+    def whoosh_schema(self):
+        ana = analysis.StemmingAnalyzer()
+        #ana = analysis.StandardAnalyzer()
+        schema = fields.Schema(head=fields.ID(stored=True),
+                               body=fields.TEXT(analyzer=ana, stored=True))
+        return schema
+
+    def zcatalog_setup(self, cat):
+        from zcatalog import indexes  #@UnresolvedImport
+        cat["head"] = indexes.FieldIndex(field_name="head")
+        cat["body"] = indexes.TextIndex(field_name="body")
+
+
+if __name__ == "__main__":
+    Bench().run(VulgarTongue)

whoosh/source/benchmark/enron.py

@@ -0,0 +1,185 @@
+from __future__ import division
+import os.path, tarfile
+from email import message_from_string
+from marshal import dump, load
+from zlib import compress, decompress
+
+try:
+    import xappy
+except ImportError:
+    pass
+
+from whoosh import analysis, fields
+from whoosh.compat import urlretrieve, next
+from whoosh.support.bench import Bench, Spec
+from whoosh.util import now
+
+
+# Benchmark class
+
+class Enron(Spec):
+    name = "enron"
+
+    enron_archive_url = "http://www.cs.cmu.edu/~enron/enron_mail_082109.tar.gz"
+    enron_archive_filename = "enron_mail_082109.tar.gz"
+    cache_filename = "enron_cache.pickle"
+
+    header_to_field = {"Date": "date", "From": "frm", "To": "to",
+                   "Subject": "subject", "Cc": "cc", "Bcc": "bcc"}
+
+    main_field = "body"
+    headline_field = "subject"
+
+    field_order = ("subject", "date", "from", "to", "cc", "bcc", "body")
+
+    cachefile = None
+
+    # Functions for downloading and then reading the email archive and caching
+    # the messages in an easier-to-digest format
+
+    def download_archive(self, archive):
+        print("Downloading Enron email archive to %r..." % archive)
+        t = now()
+        urlretrieve(self.enron_archive_url, archive)
+        print("Downloaded in ", now() - t, "seconds")
+
+    @staticmethod
+    def get_texts(archive):
+        archive = tarfile.open(archive, "r:gz")
+        while True:
+            entry = next(archive)
+            archive.members = []
+            if entry is None:
+                break
+            f = archive.extractfile(entry)
+            if f is not None:
+                text = f.read()
+                yield text
+
+    @staticmethod
+    def get_messages(archive, headers=True):
+        header_to_field = Enron.header_to_field
+        for text in Enron.get_texts(archive):
+            message = message_from_string(text)
+            body = message.as_string().decode("latin_1")
+            blank = body.find("\n\n")
+            if blank > -1:
+                body = body[blank+2:]
+            d = {"body": body}
+            if headers:
+                for k in message.keys():
+                    fn = header_to_field.get(k)
+                    if not fn: continue
+                    v = message.get(k).strip()
+                    if v:
+                        d[fn] = v.decode("latin_1")
+            yield d
+
+    def cache_messages(self, archive, cache):
+        print("Caching messages in %s..." % cache)
+
+        if not os.path.exists(archive):
+            raise Exception("Archive file %r does not exist" % archive)
+
+        t = now()
+        f = open(cache, "wb")
+        c = 0
+        for d in self.get_messages(archive):
+            c += 1
+            dump(d, f)
+            if not c % 1000: print(c)
+        f.close()
+        print("Cached messages in ", now() - t, "seconds")
+
+    def setup(self):
+        archive = os.path.abspath(os.path.join(self.options.dir, self.enron_archive_filename))
+        cache = os.path.abspath(os.path.join(self.options.dir, self.cache_filename))
+
+        if not os.path.exists(archive):
+            self.download_archive(archive)
+        else:
+            print("Archive is OK")
+
+        if not os.path.exists(cache):
+            self.cache_messages(archive, cache)
+        else:
+            print("Cache is OK")
+
+    def documents(self):
+        if not os.path.exists(self.cache_filename):
+            raise Exception("Message cache does not exist, use --setup")
+
+        f = open(self.cache_filename, "rb")
+        try:
+            while True:
+                self.filepos = f.tell()
+                d = load(f)
+                yield d
+        except EOFError:
+            pass
+        f.close()
+
+    def whoosh_schema(self):
+        ana = analysis.StemmingAnalyzer(maxsize=40, cachesize=None)
+        storebody = self.options.storebody
+        schema = fields.Schema(body=fields.TEXT(analyzer=ana, stored=storebody),
+                               filepos=fields.STORED,
+                               date=fields.ID(stored=True),
+                               frm=fields.ID(stored=True),
+                               to=fields.IDLIST(stored=True),
+                               subject=fields.TEXT(stored=True),
+                               cc=fields.IDLIST,
+                               bcc=fields.IDLIST)
+        return schema
+
+    def xappy_indexer_connection(self, path):
+        conn = xappy.IndexerConnection(path)
+        conn.add_field_action('body', xappy.FieldActions.INDEX_FREETEXT, language='en')
+        if self.options.storebody:
+            conn.add_field_action('body', xappy.FieldActions.STORE_CONTENT)
+        conn.add_field_action('date', xappy.FieldActions.INDEX_EXACT)
+        conn.add_field_action('date', xappy.FieldActions.STORE_CONTENT)
+        conn.add_field_action('frm', xappy.FieldActions.INDEX_EXACT)
+        conn.add_field_action('frm', xappy.FieldActions.STORE_CONTENT)
+        conn.add_field_action('to', xappy.FieldActions.INDEX_EXACT)
+        conn.add_field_action('to', xappy.FieldActions.STORE_CONTENT)
+        conn.add_field_action('subject', xappy.FieldActions.INDEX_FREETEXT, language='en')
+        conn.add_field_action('subject', xappy.FieldActions.STORE_CONTENT)
+        conn.add_field_action('cc', xappy.FieldActions.INDEX_EXACT)
+        conn.add_field_action('bcc', xappy.FieldActions.INDEX_EXACT)
+        return conn
+
+    def zcatalog_setup(self, cat):
+        from zcatalog import indexes
+        for name in ("date", "frm"):
+            cat[name] = indexes.FieldIndex(field_name=name)
+        for name in ("to", "subject", "cc", "bcc", "body"):
+            cat[name] = indexes.TextIndex(field_name=name)
+
+    def process_document_whoosh(self, d):
+        d["filepos"] = self.filepos
+        if self.options.storebody:
+            mf = self.main_field
+            d["_stored_%s" % mf] = compress(d[mf], 9)
+
+    def process_result_whoosh(self, d):
+        mf = self.main_field
+        if mf in d:
+            d.fields()[mf] = decompress(d[mf])
+        else:
+            if not self.cachefile:
+                self.cachefile = open(self.cache_filename, "rb")
+            filepos = d["filepos"]
+            self.cachefile.seek(filepos)
+            dd = load(self.cachefile)
+            d.fields()[mf] = dd[mf]
+        return d
+
+    def process_document_xapian(self, d):
+        d[self.main_field] = " ".join([d.get(name, "") for name
+                                       in self.field_order])
+
+
+
+if __name__=="__main__":
+    Bench().run(Enron)

whoosh/source/benchmark/marc21.py

@@ -0,0 +1,297 @@
+from __future__ import with_statement, print_function
+import fnmatch, logging, os.path, re
+
+from whoosh import analysis, fields, index, qparser, query, scoring
+from whoosh.compat import xrange
+from whoosh.util import now
+
+
+log = logging.getLogger(__name__)
+
+
+# Functions for reading MARC format
+
+LEADER = (' ' * 10) + '22' + (' ' * 8) + '4500'
+LEADER_LEN = len(LEADER)
+DIRECTORY_ENTRY_LEN = 12
+SUBFIELD_INDICATOR = "\x1F"
+END_OF_FIELD = "\x1E"
+END_OF_RECORD = "\x1D"
+isbn_regex = re.compile(r'[-0-9xX]+')
+
+
+def read_file(dbfile, tags=None):
+    while True:
+        pos = dbfile.tell()
+        first5 = dbfile.read(5)
+        if not first5:
+            return
+        if len(first5) < 5:
+            raise Exception
+        length = int(first5)
+        chunk = dbfile.read(length - 5)
+        yield parse_record(first5 + chunk, tags), pos
+
+
+def read_record(filename, pos, tags=None):
+    f = open(filename, "rb")
+    f.seek(pos)
+    first5 = f.read(5)
+    length = int(first5)
+    chunk = f.read(length - 5)
+    return parse_record(first5 + chunk, tags)
+
+
+def parse_record(data, tags=None):
+    leader = data[:LEADER_LEN]
+    assert len(leader) == LEADER_LEN
+
+    dataoffset = int(data[12:17])
+    assert dataoffset > 0
+    assert dataoffset < len(data)
+
+    # dataoffset - 1 to avoid END-OF-FIELD byte
+    dirstart = LEADER_LEN
+    dirend = dataoffset - 1
+
+    # Number of fields in record
+    assert (dirend - dirstart) % DIRECTORY_ENTRY_LEN == 0
+    field_count = (dirend - dirstart) // DIRECTORY_ENTRY_LEN
+
+    result = {}
+    for i in xrange(field_count):
+        start = dirstart + i * DIRECTORY_ENTRY_LEN
+        end = start + DIRECTORY_ENTRY_LEN
+        tag = data[start:start + 3]
+        if tags and not tag in tags:
+            continue
+
+        entry = data[start:end]
+        elen = int(entry[3:7])
+        offset = dataoffset + int(entry[7:12])
+        edata = data[offset:offset + elen - 1]
+
+        if not (tag < "010" and tag.isdigit()):
+            edata = edata.split(SUBFIELD_INDICATOR)[1:]
+            if tag in result:
+                result[tag].extend(edata)
+            else:
+                result[tag] = edata
+        else:
+            result[tag] = edata
+    return result
+
+
+def subfield(vs, code):
+    for v in vs:
+        if v.startswith(code):
+            return v[1:]
+    return None
+
+
+def joinsubfields(vs):
+    return " ".join(v[1:] for v in vs if v and v[0] != "6")
+
+
+def getfields(d, *tags):
+    return (d[tag] for tag in tags if tag in d)
+
+
+def title(d):
+    title = None
+    if "245" in d:
+        svs = d["245"]
+        title = subfield(svs, "a")
+        if title:
+            t2 = subfield(svs, "b")
+            if t2:
+                title += t2
+    return title
+
+
+def isbn(d):
+    if "020" in d:
+        num = subfield(d["020"], "a")
+        if num:
+            match = isbn_regex.search(num)
+            if match:
+                return match.group(0).replace('-', '')
+
+
+def author(d):
+    if "100" in d:
+        return joinsubfields(d["100"])
+    elif "110" in d:
+        return joinsubfields(d["110"])
+    elif "111" in d:
+        return joinsubfields(d["111"])
+
+
+def uniform_title(d):
+    if "130" in d:
+        return joinsubfields(d["130"])
+    elif "240" in d:
+        return joinsubfields(d["240"])
+
+
+subjectfields = ("600 610 611 630 648 650 651 653 654 655 656 657 658 662 "
+                 "690 691 696 697 698 699").split()
+
+
+def subjects(d):
+    return " ".join(joinsubfields(vs) for vs in getfields(d, *subjectfields))
+
+
+def physical(d):
+    return joinsubfields(d["300"])
+
+
+def location(d):
+    return joinsubfields(d["852"])
+
+
+def publisher(d):
+    if "260" in d:
+        return subfield(d["260"], "b")
+
+
+def pubyear(d):
+    if "260" in d:
+        return subfield(d["260"], "c")
+
+
+def uni(v):
+    return u"" if v is None else v.decode("utf-8", "replace")
+
+
+# Indexing and searching
+
+def make_index(basedir, ixdir, procs=4, limitmb=128, multisegment=True,
+               glob="*.mrc"):
+    if not os.path.exists(ixdir):
+        os.mkdir(ixdir)
+
+    # Multi-lingual stop words
+    stoplist = (analysis.STOP_WORDS
+                | set("de la der und le die et en al no von di du da "
+                      "del zur ein".split()))
+    # Schema
+    ana = analysis.StemmingAnalyzer(stoplist=stoplist)
+    schema = fields.Schema(title=fields.TEXT(analyzer=ana),
+                           author=fields.TEXT(phrase=False),
+                           subject=fields.TEXT(analyzer=ana, phrase=False),
+                           file=fields.STORED, pos=fields.STORED,
+                           )
+
+    # MARC fields to extract
+    mfields = set(subjectfields)  # Subjects
+    mfields.update("100 110 111".split())  # Author
+    mfields.add("245")  # Title
+
+    print("Indexing with %d processor(s) and %d MB per processor"
+          % (procs, limitmb))
+    c = 0
+    t = now()
+    ix = index.create_in(ixdir, schema)
+    with ix.writer(procs=procs, limitmb=limitmb,
+                   multisegment=multisegment) as w:
+        filenames = [filename for filename in os.listdir(basedir)
+                     if fnmatch.fnmatch(filename, glob)]
+        for filename in filenames:
+            path = os.path.join(basedir, filename)
+            print("Indexing", path)
+            f = open(path, 'rb')
+            for x, pos in read_file(f, mfields):
+                w.add_document(title=uni(title(x)), author=uni(author(x)),
+                               subject=uni(subjects(x)),
+                               file=filename, pos=pos)
+                c += 1
+            f.close()
+        print("Committing...")
+    print("Indexed %d records in %0.02f minutes" % (c, (now() - t) / 60.0))
+
+
+def print_record(no, basedir, filename, pos):
+    path = os.path.join(basedir, filename)
+    record = read_record(path, pos)
+    print("% 5d. %s" % (no + 1, title(record)))
+    print("      ", author(record))
+    print("      ", subjects(record))
+    isbn_num = isbn(record)
+    if isbn_num:
+        print(" ISBN:", isbn_num)
+    print()
+
+
+def search(qstring, ixdir, basedir, limit=None, optimize=True, scores=True):
+    ix = index.open_dir(ixdir)
+    qp = qparser.QueryParser("title", ix.schema)
+    q = qp.parse(qstring)
+
+    with ix.searcher(weighting=scoring.PL2()) as s:
+        if scores:
+            r = s.search(q, limit=limit, optimize=optimize)
+            for hit in r:
+                print_record(hit.rank, basedir, hit["file"], hit["pos"])
+            print("Found %d records in %0.06f seconds" % (len(r), r.runtime))
+        else:
+            t = now()
+            for i, docnum in enumerate(s.docs_for_query(q)):
+                if not limit or i < limit:
+                    fields = s.stored_fields(docnum)
+                    print_record(i, basedir, fields["file"], fields["pos"])
+            print("Found %d records in %0.06f seconds" % (i, now() - t))
+
+
+if __name__ == "__main__":
+    from optparse import OptionParser
+
+    p = OptionParser(usage="usage: %prog [options] query")
+    # Common options
+    p.add_option("-f", "--filedir", metavar="DIR", dest="basedir",
+                 help="Directory containing the .mrc files to index",
+                 default="data/HLOM")
+    p.add_option("-d", "--dir", metavar="DIR", dest="ixdir",
+                 help="Directory containing the index", default="marc_index")
+
+    # Indexing options
+    p.add_option("-i", "--index", dest="index",
+                 help="Index the records", action="store_true", default=False)
+    p.add_option("-p", "--procs", metavar="NPROCS", dest="procs",
+                 help="Number of processors to use", default="1")
+    p.add_option("-m", "--mb", metavar="MB", dest="limitmb",
+                 help="Limit the indexer to this many MB of memory per writer",
+                 default="128")
+    p.add_option("-M", "--merge-segments", dest="multisegment",
+                 help="If indexing with multiproc, merge the segments after"
+                 " indexing", action="store_false", default=True)
+    p.add_option("-g", "--match", metavar="GLOB", dest="glob",
+                 help="Only index file names matching the given pattern",
+                 default="*.mrc")
+
+    # Search options
+    p.add_option("-l", "--limit", metavar="NHITS", dest="limit",
+                 help="Maximum number of search results to print (0=no limit)",
+                 default="10")
+    p.add_option("-O", "--no-optimize", dest="optimize",
+                 help="Turn off searcher optimization (for debugging)",
+                 action="store_false", default=True)
+    p.add_option("-s", "--scoring", dest="scores",
+                 help="Score the results", action="store_true", default=False)
+
+    options, args = p.parse_args()
+
+    if options.index:
+        make_index(options.basedir, options.ixdir,
+                   procs=int(options.procs),
+                   limitmb=int(options.limitmb),
+                   multisegment=options.multisegment,
+                   glob=options.glob)
+
+    if args:
+        qstring = " ".join(args).decode("utf-8")
+        limit = int(options.limit)
+        if limit < 1:
+            limit = None
+        search(qstring, options.ixdir, options.basedir, limit=limit,
+               optimize=options.optimize, scores=options.scores)

whoosh/source/benchmark/reuters.py

@@ -0,0 +1,38 @@
+import gzip, os.path
+
+from whoosh import analysis, fields, index, qparser, query
+from whoosh.support.bench import Bench, Spec
+from whoosh.util import now
+
+
+class Reuters(Spec):
+    name = "reuters"
+    filename = "reuters21578.txt.gz"
+    main_field = "text"
+    headline_text = "headline"
+
+    def whoosh_schema(self):
+        #ana = analysis.StemmingAnalyzer()
+        ana = analysis.StandardAnalyzer()
+        schema = fields.Schema(id=fields.ID(stored=True),
+                               headline=fields.STORED,
+                               text=fields.TEXT(analyzer=ana, stored=True))
+        return schema
+
+    def zcatalog_setup(self, cat):
+        from zcatalog import indexes  #@UnresolvedImport
+        cat["id"] = indexes.FieldIndex(field_name="id")
+        cat["headline"] = indexes.TextIndex(field_name="headline")
+        cat["body"] = indexes.TextIndex(field_name="text")
+
+    def documents(self):
+        path = os.path.join(self.options.dir, self.filename)
+        f = gzip.GzipFile(path)
+
+        for line in f:
+            id, text = line.decode("latin1").split("\t")
+            yield {"id": id, "text": text, "headline": text[:70]}
+
+
+if __name__ == "__main__":
+    Bench().run(Reuters)

whoosh/source/benchmark/reuters21578.txt.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3e27185a494675296d75a4332c91e380bf4d8c49e0b074fa761e8b76d2881063
+size 181938

whoosh/source/docs/Makefile

@@ -0,0 +1,130 @@
+# Makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+PAPER         =
+BUILDDIR      = build
+
+# Internal variables.
+PAPEROPT_a4     = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source
+
+.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest
+
+help:
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  html       to make standalone HTML files"
+	@echo "  dirhtml    to make HTML files named index.html in directories"
+	@echo "  singlehtml to make a single large HTML file"
+	@echo "  pickle     to make pickle files"
+	@echo "  json       to make JSON files"
+	@echo "  htmlhelp   to make HTML files and a HTML help project"
+	@echo "  qthelp     to make HTML files and a qthelp project"
+	@echo "  devhelp    to make HTML files and a Devhelp project"
+	@echo "  epub       to make an epub"
+	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
+	@echo "  text       to make text files"
+	@echo "  man        to make manual pages"
+	@echo "  changes    to make an overview of all changed/added/deprecated items"
+	@echo "  linkcheck  to check all external links for integrity"
+	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
+
+clean:
+	-rm -rf $(BUILDDIR)/*
+
+html:
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
+
+dirhtml:
+	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
+
+singlehtml:
+	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
+	@echo
+	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
+
+pickle:
+	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
+	@echo
+	@echo "Build finished; now you can process the pickle files."
+
+json:
+	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
+	@echo
+	@echo "Build finished; now you can process the JSON files."
+
+htmlhelp:
+	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
+	@echo
+	@echo "Build finished; now you can run HTML Help Workshop with the" \
+	      ".hhp project file in $(BUILDDIR)/htmlhelp."
+
+qthelp:
+	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
+	@echo
+	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
+	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
+	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/Whoosh.qhcp"
+	@echo "To view the help file:"
+	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Whoosh.qhc"
+
+devhelp:
+	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
+	@echo
+	@echo "Build finished."
+	@echo "To view the help file:"
+	@echo "# mkdir -p $$HOME/.local/share/devhelp/Whoosh"
+	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Whoosh"
+	@echo "# devhelp"
+
+epub:
+	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
+	@echo
+	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
+
+latex:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo
+	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
+	@echo "Run \`make' in that directory to run these through (pdf)latex" \
+	      "(use \`make latexpdf' here to do that automatically)."
+
+latexpdf:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through pdflatex..."
+	make -C $(BUILDDIR)/latex all-pdf
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+text:
+	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
+	@echo
+	@echo "Build finished. The text files are in $(BUILDDIR)/text."
+
+man:
+	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
+	@echo
+	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
+
+changes:
+	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
+	@echo
+	@echo "The overview file is in $(BUILDDIR)/changes."
+
+linkcheck:
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
+	@echo
+	@echo "Link check complete; look for any errors in the above output " \
+	      "or in $(BUILDDIR)/linkcheck/output.txt."
+
+doctest:
+	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
+	@echo "Testing of doctests in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/doctest/output.txt."

whoosh/source/docs/make.bat

@@ -0,0 +1,170 @@
+@ECHO OFF
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set BUILDDIR=build
+set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% source
+if NOT "%PAPER%" == "" (
+	set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS%
+)
+
+if "%1" == "" goto help
+
+if "%1" == "help" (
+	:help
+	echo.Please use `make ^<target^>` where ^<target^> is one of
+	echo.  html       to make standalone HTML files
+	echo.  dirhtml    to make HTML files named index.html in directories
+	echo.  singlehtml to make a single large HTML file
+	echo.  pickle     to make pickle files
+	echo.  json       to make JSON files
+	echo.  htmlhelp   to make HTML files and a HTML help project
+	echo.  qthelp     to make HTML files and a qthelp project
+	echo.  devhelp    to make HTML files and a Devhelp project
+	echo.  epub       to make an epub
+	echo.  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter
+	echo.  text       to make text files
+	echo.  man        to make manual pages
+	echo.  changes    to make an overview over all changed/added/deprecated items
+	echo.  linkcheck  to check all external links for integrity
+	echo.  doctest    to run all doctests embedded in the documentation if enabled
+	goto end
+)
+
+if "%1" == "clean" (
+	for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i
+	del /q /s %BUILDDIR%\*
+	goto end
+)
+
+if "%1" == "html" (
+	%SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The HTML pages are in %BUILDDIR%/html.
+	goto end
+)
+
+if "%1" == "dirhtml" (
+	%SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml.
+	goto end
+)
+
+if "%1" == "singlehtml" (
+	%SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml.
+	goto end
+)
+
+if "%1" == "pickle" (
+	%SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can process the pickle files.
+	goto end
+)
+
+if "%1" == "json" (
+	%SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can process the JSON files.
+	goto end
+)
+
+if "%1" == "htmlhelp" (
+	%SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can run HTML Help Workshop with the ^
+.hhp project file in %BUILDDIR%/htmlhelp.
+	goto end
+)
+
+if "%1" == "qthelp" (
+	%SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can run "qcollectiongenerator" with the ^
+.qhcp project file in %BUILDDIR%/qthelp, like this:
+	echo.^> qcollectiongenerator %BUILDDIR%\qthelp\Whoosh.qhcp
+	echo.To view the help file:
+	echo.^> assistant -collectionFile %BUILDDIR%\qthelp\Whoosh.ghc
+	goto end
+)
+
+if "%1" == "devhelp" (
+	%SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished.
+	goto end
+)
+
+if "%1" == "epub" (
+	%SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The epub file is in %BUILDDIR%/epub.
+	goto end
+)
+
+if "%1" == "latex" (
+	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; the LaTeX files are in %BUILDDIR%/latex.
+	goto end
+)
+
+if "%1" == "text" (
+	%SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The text files are in %BUILDDIR%/text.
+	goto end
+)
+
+if "%1" == "man" (
+	%SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The manual pages are in %BUILDDIR%/man.
+	goto end
+)
+
+if "%1" == "changes" (
+	%SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.The overview file is in %BUILDDIR%/changes.
+	goto end
+)
+
+if "%1" == "linkcheck" (
+	%SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Link check complete; look for any errors in the above output ^
+or in %BUILDDIR%/linkcheck/output.txt.
+	goto end
+)
+
+if "%1" == "doctest" (
+	%SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Testing of doctests in the sources finished, look at the ^
+results in %BUILDDIR%/doctest/output.txt.
+	goto end
+)
+
+:end

whoosh/source/docs/source/analysis.rst

@@ -0,0 +1,329 @@
+===============
+About analyzers
+===============
+
+Overview
+========
+
+An analyzer is a function or callable class (a class with a ``__call__`` method)
+that takes a unicode string and returns a generator of tokens. Usually a "token"
+is a word, for example the string "Mary had a little lamb" might yield the
+tokens "Mary", "had", "a", "little", and "lamb". However, tokens do not
+necessarily correspond to words. For example, you might tokenize Chinese text
+into individual characters or bi-grams. Tokens are the units of indexing, that
+is, they are what you are able to look up in the index.
+
+An analyzer is basically just a wrapper for a tokenizer and zero or more
+filters. The analyzer's ``__call__`` method will pass its parameters to a
+tokenizer, and the tokenizer will usually be wrapped in a few filters.
+
+A tokenizer is a callable that takes a unicode string and yields a series of
+``analysis.Token`` objects.
+
+For example, the provided :class:`whoosh.analysis.RegexTokenizer` class
+implements a customizable, regular-expression-based tokenizer that extracts
+words and ignores whitespace and punctuation.
+
+::
+
+    >>> from whoosh.analysis import RegexTokenizer
+    >>> tokenizer = RegexTokenizer()
+    >>> for token in tokenizer(u"Hello there my friend!"):
+    ...   print repr(token.text)
+    u'Hello'
+    u'there'
+    u'my'
+    u'friend'
+
+A filter is a callable that takes a generator of Tokens (either a tokenizer or
+another filter) and in turn yields a series of Tokens.
+
+For example, the provided :meth:`whoosh.analysis.LowercaseFilter` filters tokens
+by converting their text to lowercase. The implementation is very simple::
+
+    def LowercaseFilter(tokens):
+        """Uses lower() to lowercase token text. For example, tokens
+        "This","is","a","TEST" become "this","is","a","test".
+        """
+
+        for t in tokens:
+            t.text = t.text.lower()
+            yield t
+
+You can wrap the filter around a tokenizer to see it in operation::
+
+    >>> from whoosh.analysis import LowercaseFilter
+    >>> for token in LowercaseFilter(tokenizer(u"These ARE the things I want!")):
+    ...   print repr(token.text)
+    u'these'
+    u'are'
+    u'the'
+    u'things'
+    u'i'
+    u'want'
+
+An analyzer is just a means of combining a tokenizer and some filters into a
+single package.
+
+You can implement an analyzer as a custom class or function, or compose
+tokenizers and filters together using the ``|`` character::
+
+    my_analyzer = RegexTokenizer() | LowercaseFilter() | StopFilter()
+
+The first item must be a tokenizer and the rest must be filters (you can't put a
+filter first or a tokenizer after the first item). Note that this only works if at
+least the tokenizer is a subclass of ``whoosh.analysis.Composable``, as all the
+tokenizers and filters that ship with Whoosh are.
+
+See the :mod:`whoosh.analysis` module for information on the available analyzers,
+tokenizers, and filters shipped with Whoosh.
+
+
+Using analyzers
+===============
+
+When you create a field in a schema, you can specify your analyzer as a keyword
+argument to the field object::
+
+    schema = Schema(content=TEXT(analyzer=StemmingAnalyzer()))
+
+
+Advanced Analysis
+=================
+
+Token objects
+-------------
+
+The ``Token`` class has no methods. It is merely a place to record certain
+attributes. A ``Token`` object actually has two kinds of attributes: *settings*
+that record what kind of information the ``Token`` object does or should contain,
+and *information* about the current token.
+
+
+Token setting attributes
+------------------------
+
+A ``Token`` object should always have the following attributes. A tokenizer or
+filter can check these attributes to see what kind of information is available
+and/or what kind of information they should be setting on the ``Token`` object.
+
+These attributes are set by the tokenizer when it creates the Token(s), based on
+the parameters passed to it from the Analyzer.
+
+Filters **should not** change the values of these attributes.
+
+====== ================ =================================================== =========
+Type   Attribute name   Description                                         Default
+====== ================ =================================================== =========
+str    mode             The mode in which the analyzer is being called,     ''
+                        e.g. 'index' during indexing or 'query' during
+                        query parsing
+bool   positions        Whether term positions are recorded in the token    False
+bool   chars            Whether term start and end character indices are    False
+                        recorded in the token
+bool   boosts           Whether per-term boosts are recorded in the token   False
+bool   removestops      Whether stop-words should be removed from the       True
+                        token stream
+====== ================ =================================================== =========
+
+
+Token information attributes
+----------------------------
+
+A ``Token`` object may have any of the following attributes. The ``text`` attribute
+should always be present. The original attribute may be set by a tokenizer. All
+other attributes should only be accessed or set based on the values of the
+"settings" attributes above.
+
+======== ========== =================================================================
+Type     Name       Description
+======== ========== =================================================================
+unicode  text       The text of the token (this should always be present)
+unicode  original   The original (pre-filtered) text of the token. The tokenizer may
+                    record this, and filters are expected not to modify it.
+int      pos        The position of the token in the stream, starting at 0
+                    (only set if positions is True)
+int      startchar  The character index of the start of the token in the original
+                    string (only set if chars is True)
+int      endchar    The character index of the end of the token in the original
+                    string (only set if chars is True)
+float    boost      The boost for this token (only set if boosts is True)
+bool     stopped    Whether this token is a "stop" word
+                    (only set if removestops is False)
+======== ========== =================================================================
+
+So why are most of the information attributes optional? Different field formats
+require different levels of information about each token. For example, the
+``Frequency`` format only needs the token text. The ``Positions`` format records term
+positions, so it needs them on the ``Token``. The ``Characters`` format records term
+positions and the start and end character indices of each term, so it needs them
+on the token, and so on.
+
+The ``Format`` object that represents the format of each field calls the analyzer
+for the field, and passes it parameters corresponding to the types of
+information it needs, e.g.::
+
+    analyzer(unicode_string, positions=True)
+
+The analyzer can then pass that information to a tokenizer so the tokenizer
+initializes the required attributes on the ``Token`` object(s) it produces.
+
+
+Performing different analysis for indexing and query parsing
+------------------------------------------------------------
+
+Whoosh sets the ``mode`` setting attribute to indicate whether the analyzer is
+being called by the indexer (``mode='index'``) or the query parser
+(``mode='query'``). This is useful if there's a transformation that you only
+want to apply at indexing or query parsing::
+
+    class MyFilter(Filter):
+        def __call__(self, tokens):
+            for t in tokens:
+                if t.mode == 'query':
+                    ...
+                else:
+                    ...
+
+The :class:`whoosh.analysis.MultiFilter` filter class lets you specify different
+filters to use based on the mode setting::
+
+    intraword = MultiFilter(index=IntraWordFilter(mergewords=True, mergenums=True),
+                            query=IntraWordFilter(mergewords=False, mergenums=False))
+
+
+Stop words
+----------
+
+"Stop" words are words that are so common it's often counter-productive to index
+them, such as "and", "or", "if", etc. The provided ``analysis.StopFilter`` lets you
+filter out stop words, and includes a default list of common stop words.
+
+::
+
+    >>> from whoosh.analysis import StopFilter
+    >>> stopper = StopFilter()
+    >>> for token in stopper(LowercaseFilter(tokenizer(u"These ARE the things I want!"))):
+    ...   print repr(token.text)
+    u'these'
+    u'things'
+    u'want'
+
+However, this seemingly simple filter idea raises a couple of minor but slightly
+thorny issues: renumbering term positions and keeping or removing stopped words.
+
+
+Renumbering term positions
+--------------------------
+
+Remember that analyzers are sometimes asked to record the position of each token
+in the token stream:
+
+============= ========== ========== ========== ==========
+Token.text    u'Mary'    u'had'     u'a'       u'lamb'
+Token.pos     0          1          2          3
+============= ========== ========== ========== ==========
+
+So what happens to the ``pos`` attribute of the tokens if ``StopFilter`` removes
+the words ``had`` and ``a`` from the stream? Should it renumber the positions to
+pretend the "stopped" words never existed? I.e.:
+
+============= ========== ==========
+Token.text    u'Mary'    u'lamb'
+Token.pos     0          1
+============= ========== ==========
+
+or should it preserve the original positions of the words? I.e:
+
+============= ========== ==========
+Token.text    u'Mary'    u'lamb'
+Token.pos     0          3
+============= ========== ==========
+
+It turns out that different situations call for different solutions, so the
+provided ``StopFilter`` class supports both of the above behaviors. Renumbering
+is the default, since that is usually the most useful and is necessary to
+support phrase searching. However, you can set a parameter in StopFilter's
+constructor to tell it not to renumber positions::
+
+    stopper = StopFilter(renumber=False)
+
+
+Removing or leaving stop words
+------------------------------
+
+The point of using ``StopFilter`` is to remove stop words, right? Well, there
+are actually some situations where you might want to mark tokens as "stopped"
+but not remove them from the token stream.
+
+For example, if you were writing your own query parser, you could run the user's
+query through a field's analyzer to break it into tokens. In that case, you
+might want to know which words were "stopped" so you can provide helpful
+feedback to the end user (e.g. "The following words are too common to search
+for:").
+
+In other cases, you might want to leave stopped words in the stream for certain
+filtering steps (for example, you might have a step that looks at previous
+tokens, and want the stopped tokens to be part of the process), but then remove
+them later.
+
+The ``analysis`` module provides a couple of tools for keeping and removing
+stop-words in the stream.
+
+The ``removestops`` parameter passed to the analyzer's ``__call__`` method (and
+copied to the ``Token`` object as an attribute) specifies whether stop words should
+be removed from the stream or left in.
+
+::
+
+    >>> from whoosh.analysis import StandardAnalyzer
+    >>> analyzer = StandardAnalyzer()
+    >>> [(t.text, t.stopped) for t in analyzer(u"This is a test")]
+    [(u'test', False)]
+    >>> [(t.text, t.stopped) for t in analyzer(u"This is a test", removestops=False)]
+    [(u'this', True), (u'is', True), (u'a', True), (u'test', False)]
+
+The ``analysis.unstopped()`` filter function takes a token generator and yields
+only the tokens whose ``stopped`` attribute is ``False``.
+
+.. note::
+    Even if you leave stopped words in the stream in an analyzer you use for
+    indexing, the indexer will ignore any tokens where the ``stopped``
+    attribute is ``True``.
+
+
+Implementation notes
+--------------------
+
+Because object creation is slow in Python, the stock tokenizers do not create a
+new ``analysis.Token`` object for each token. Instead, they create one ``Token`` object
+and yield it over and over. This is a nice performance shortcut but can lead to
+strange behavior if your code tries to remember tokens between loops of the
+generator.
+
+Because the analyzer only has one ``Token`` object, of which it keeps changing the
+attributes, if you keep a copy of the Token you get from a loop of the
+generator, it will be changed from under you. For example::
+
+    >>> list(tokenizer(u"Hello there my friend"))
+    [Token(u"friend"), Token(u"friend"), Token(u"friend"), Token(u"friend")]
+
+Instead, do this::
+
+    >>> [t.text for t in tokenizer(u"Hello there my friend")]
+
+That is, save the attributes, not the token object itself.
+
+If you implement your own tokenizer, filter, or analyzer as a class, you should
+implement an ``__eq__`` method. This is important to allow comparison of ``Schema``
+objects.
+
+The mixing of persistent "setting" and transient "information" attributes on the
+``Token`` object is not especially elegant. If I ever have a better idea I might
+change it. ;) Nothing requires that an Analyzer be implemented by calling a
+tokenizer and filters. Tokenizers and filters are simply a convenient way to
+structure the code. You're free to write an analyzer any way you want, as long
+as it implements ``__call__``.
+
+
+

whoosh/source/docs/source/api/analysis.rst

@@ -0,0 +1,62 @@
+===================
+``analysis`` module
+===================
+
+.. automodule:: whoosh.analysis
+
+Analyzers
+=========
+
+.. autofunction:: IDAnalyzer
+.. autofunction:: KeywordAnalyzer
+.. autofunction:: RegexAnalyzer
+.. autofunction:: SimpleAnalyzer
+.. autofunction:: StandardAnalyzer
+.. autofunction:: StemmingAnalyzer
+.. autofunction:: FancyAnalyzer
+.. autofunction:: NgramAnalyzer
+.. autofunction:: NgramWordAnalyzer
+.. autofunction:: LanguageAnalyzer
+
+
+Tokenizers
+==========
+
+.. autoclass:: IDTokenizer
+.. autoclass:: RegexTokenizer
+.. autoclass:: CharsetTokenizer
+.. autofunction:: SpaceSeparatedTokenizer
+.. autofunction:: CommaSeparatedTokenizer
+.. autoclass:: NgramTokenizer
+.. autoclass:: PathTokenizer
+
+
+Filters
+=======
+
+.. autoclass:: PassFilter
+.. autoclass:: LoggingFilter
+.. autoclass:: MultiFilter
+.. autoclass:: TeeFilter
+.. autoclass:: ReverseTextFilter
+.. autoclass:: LowercaseFilter
+.. autoclass:: StripFilter
+.. autoclass:: StopFilter
+.. autoclass:: StemFilter
+.. autoclass:: CharsetFilter
+.. autoclass:: NgramFilter
+.. autoclass:: IntraWordFilter
+.. autoclass:: CompoundWordFilter
+.. autoclass:: BiWordFilter
+.. autoclass:: ShingleFilter
+.. autoclass:: DelimitedAttributeFilter
+.. autoclass:: DoubleMetaphoneFilter
+.. autoclass:: SubstitutionFilter
+
+
+Token classes and functions
+===========================
+
+.. autoclass:: Token
+.. autofunction:: unstopped
+

whoosh/source/docs/source/api/api.rst

@@ -0,0 +1,9 @@
+==========
+Whoosh API
+==========
+
+.. toctree::
+    :glob:
+    :maxdepth: 1
+
+    **

whoosh/source/docs/source/api/codec/base.rst

@@ -0,0 +1,32 @@
+=====================
+``codec.base`` module
+=====================
+
+.. automodule:: whoosh.codec.base
+
+
+Classes
+=======
+
+.. autoclass:: Codec
+   :members:
+
+.. autoclass:: PerDocumentWriter
+   :members:
+
+.. autoclass:: FieldWriter
+   :members:
+
+.. autoclass:: PostingsWriter
+   :members:
+
+.. autoclass:: TermsReader
+   :members:
+
+.. autoclass:: PerDocumentReader
+   :members:
+
+.. autoclass:: Segment
+   :members:
+
+

whoosh/source/docs/source/api/collectors.rst

@@ -0,0 +1,47 @@
+=====================
+``collectors`` module
+=====================
+
+.. automodule:: whoosh.collectors
+
+
+Base classes
+============
+
+.. autoclass:: Collector
+    :members:
+
+.. autoclass:: ScoredCollector
+    :members:
+
+.. autoclass:: WrappingCollector
+    :members:
+
+
+Basic collectors
+================
+
+.. autoclass:: TopCollector
+
+.. autoclass:: UnlimitedCollector
+
+.. autoclass:: SortingCollector
+
+
+Wrappers
+========
+
+.. autoclass:: FilterCollector
+
+.. autoclass:: FacetCollector
+
+.. autoclass:: CollapseCollector
+
+.. autoclass:: TimeLimitCollector
+
+.. autoclass:: TermsCollector
+
+
+
+
+

whoosh/source/docs/source/api/columns.rst

@@ -0,0 +1,49 @@
+=====================
+``columns`` module
+=====================
+
+.. automodule:: whoosh.columns
+
+
+Base classes
+============
+
+.. autoclass:: Column
+    :members:
+
+.. autoclass:: ColumnWriter
+    :members:
+
+.. autoclass:: ColumnReader
+    :members:
+
+
+Basic columns
+=============
+
+.. autoclass:: VarBytesColumn
+
+.. autoclass:: FixedBytesColumn
+
+.. autoclass:: RefBytesColumn
+
+.. autoclass:: NumericColumn
+
+
+Technical columns
+=================
+
+.. autoclass:: BitColumn
+
+.. autoclass:: CompressedBytesColumn
+
+.. autoclass:: StructColumn
+
+.. autoclass:: PickleColumn
+
+
+Experimental columns
+====================
+
+.. autoclass:: ClampedNumericColumn
+

whoosh/source/docs/source/api/fields.rst

@@ -0,0 +1,41 @@
+=================
+``fields`` module
+=================
+
+.. automodule:: whoosh.fields
+
+Schema class
+============
+
+.. autoclass:: Schema
+    :members:
+
+.. autoclass:: SchemaClass
+
+FieldType base class
+====================
+
+.. autoclass:: FieldType
+    :members:
+
+
+Pre-made field types
+====================
+
+.. autoclass:: ID
+.. autoclass:: IDLIST
+.. autoclass:: STORED
+.. autoclass:: KEYWORD
+.. autoclass:: TEXT
+.. autoclass:: NUMERIC
+.. autoclass:: DATETIME
+.. autoclass:: BOOLEAN
+.. autoclass:: NGRAM
+.. autoclass:: NGRAMWORDS
+
+
+Exceptions
+==========
+
+.. autoexception:: FieldConfigurationError
+.. autoexception:: UnknownFieldError

whoosh/source/docs/source/api/filedb/filestore.rst

@@ -0,0 +1,31 @@
+===========================
+``filedb.filestore`` module
+===========================
+
+.. automodule:: whoosh.filedb.filestore
+
+Base class
+==========
+
+.. autoclass:: Storage
+    :members:
+
+
+Implementation classes
+======================
+
+.. autoclass:: FileStorage
+.. autoclass:: RamStorage
+
+
+Helper functions
+================
+
+.. autofunction:: copy_storage
+.. autofunction:: copy_to_ram
+
+
+Exceptions
+==========
+
+.. autoexception:: ReadOnlyError

whoosh/source/docs/source/api/filedb/filetables.rst

@@ -0,0 +1,22 @@
+============================
+``filedb.filetables`` module
+============================
+
+.. automodule:: whoosh.filedb.filetables
+
+
+Hash file
+=========
+
+.. autoclass:: HashWriter
+    :members:
+
+.. autoclass:: HashReader
+    :members:
+
+
+Ordered Hash file
+=================
+
+.. autoclass:: OrderedHashWriter
+.. autoclass:: OrderedHashReader

whoosh/source/docs/source/api/filedb/structfile.rst

@@ -0,0 +1,14 @@
+============================
+``filedb.structfile`` module
+============================
+
+.. automodule:: whoosh.filedb.structfile
+
+Classes
+=======
+
+.. autoclass:: StructFile
+    :members:
+
+.. autoclass:: BufferFile
+.. autoclass:: ChecksumFile

whoosh/source/docs/source/api/formats.rst

@@ -0,0 +1,24 @@
+==================
+``formats`` module
+==================
+
+.. automodule:: whoosh.formats
+
+Base class
+==========
+
+.. autoclass:: Format
+    :members:
+
+
+Formats
+=======
+
+.. autoclass:: Existence
+.. autoclass:: Frequency
+.. autoclass:: Positions
+.. autoclass:: Characters
+.. autoclass:: PositionBoosts
+.. autoclass:: CharacterBoosts
+
+

whoosh/source/docs/source/api/highlight.rst

@@ -0,0 +1,50 @@
+====================
+``highlight`` module
+====================
+
+.. automodule:: whoosh.highlight
+
+See :doc:`how to highlight terms in search results </highlight>`.
+
+
+Manual highlighting
+===================
+
+.. autoclass:: Highlighter
+   :members:
+
+.. autofunction:: highlight
+
+
+Fragmenters
+===========
+
+.. autoclass:: Fragmenter
+   :members:
+
+.. autoclass:: WholeFragmenter
+.. autoclass:: SentenceFragmenter
+.. autoclass:: ContextFragmenter
+.. autoclass:: PinpointFragmenter
+
+
+Scorers
+=======
+
+.. autoclass:: FragmentScorer
+.. autoclass:: BasicFragmentScorer
+
+
+Formatters
+==========
+
+.. autoclass:: UppercaseFormatter
+.. autoclass:: HtmlFormatter
+.. autoclass:: GenshiFormatter
+
+
+Utility classes
+===============
+
+.. autoclass:: Fragment
+    :members:

whoosh/source/docs/source/api/idsets.rst

@@ -0,0 +1,23 @@
+============================
+``support.bitvector`` module
+============================
+
+.. automodule:: whoosh.idsets
+
+
+Base classes
+============
+
+.. autoclass:: DocIdSet
+    :members:
+
+.. autoclass:: BaseBitSet
+
+
+Implementation classes
+======================
+
+.. autoclass:: BitSet
+.. autoclass:: OnDiskBitSet
+.. autoclass:: SortedIntSet
+.. autoclass:: MultiIdSet

whoosh/source/docs/source/api/index.rst

@@ -0,0 +1,39 @@
+================
+``index`` module
+================
+
+.. automodule:: whoosh.index
+
+
+Functions
+=========
+
+.. autofunction:: create_in
+.. autofunction:: open_dir
+.. autofunction:: exists_in
+.. autofunction:: exists
+.. autofunction:: version_in
+.. autofunction:: version
+
+
+Base class
+==========
+
+.. autoclass:: Index
+    :members:
+
+
+Implementation
+==============
+
+.. autoclass:: FileIndex
+
+
+Exceptions
+==========
+
+.. autoexception:: LockError
+.. autoexception:: IndexError
+.. autoexception:: IndexVersionError
+.. autoexception:: OutOfDateError
+.. autoexception:: EmptyIndexError

whoosh/source/docs/source/api/lang/morph_en.rst

@@ -0,0 +1,7 @@
+========================
+``lang.morph_en`` module
+========================
+
+.. automodule:: whoosh.lang.morph_en
+
+.. autofunction:: variations

whoosh/source/docs/source/api/lang/porter.rst

@@ -0,0 +1,7 @@
+======================
+``lang.porter`` module
+======================
+
+.. automodule:: whoosh.lang.porter
+
+.. autofunction:: stem

whoosh/source/docs/source/api/lang/wordnet.rst

@@ -0,0 +1,20 @@
+========================
+``lang.wordnet`` module
+========================
+
+.. automodule:: whoosh.lang.wordnet
+
+Thesaurus
+=========
+
+.. autoclass:: Thesaurus
+    :members:
+
+
+Low-level functions
+===================
+
+.. autofunction:: parse_file
+.. autofunction:: synonyms
+.. autofunction:: make_index
+

whoosh/source/docs/source/api/matching.rst

@@ -0,0 +1,34 @@
+===================
+``matching`` module
+===================
+
+.. automodule:: whoosh.matching
+
+Matchers
+========
+
+.. autoclass:: Matcher
+    :members:
+
+.. autoclass:: NullMatcher
+.. autoclass:: ListMatcher
+.. autoclass:: WrappingMatcher
+.. autoclass:: MultiMatcher
+.. autoclass:: FilterMatcher
+.. autoclass:: BiMatcher
+.. autoclass:: AdditiveBiMatcher
+.. autoclass:: UnionMatcher
+.. autoclass:: DisjunctionMaxMatcher
+.. autoclass:: IntersectionMatcher
+.. autoclass:: AndNotMatcher
+.. autoclass:: InverseMatcher
+.. autoclass:: RequireMatcher
+.. autoclass:: AndMaybeMatcher
+.. autoclass:: ConstantScoreMatcher
+
+
+Exceptions
+==========
+
+.. autoexception:: ReadTooFar
+.. autoexception:: NoQualityAvailable

whoosh/source/docs/source/api/qparser.rst

@@ -0,0 +1,97 @@
+==================
+``qparser`` module
+==================
+
+.. automodule:: whoosh.qparser
+
+Parser object
+=============
+
+.. autoclass:: QueryParser
+    :members:
+
+Pre-made configurations
+-----------------------
+
+The following functions return pre-configured QueryParser objects.
+
+.. autofunction:: MultifieldParser
+
+.. autofunction:: SimpleParser
+
+.. autofunction:: DisMaxParser
+
+
+Plug-ins
+========
+
+.. autoclass:: Plugin
+    :members:
+
+.. autoclass:: SingleQuotePlugin
+.. autoclass:: PrefixPlugin
+.. autoclass:: WildcardPlugin
+.. autoclass:: RegexPlugin
+.. autoclass:: BoostPlugin
+.. autoclass:: GroupPlugin
+.. autoclass:: EveryPlugin
+.. autoclass:: FieldsPlugin
+.. autoclass:: PhrasePlugin
+.. autoclass:: RangePlugin
+.. autoclass:: OperatorsPlugin
+.. autoclass:: PlusMinusPlugin
+.. autoclass:: GtLtPlugin
+.. autoclass:: MultifieldPlugin
+.. autoclass:: FieldAliasPlugin
+.. autoclass:: CopyFieldPlugin
+
+
+Syntax node objects
+===================
+
+Base nodes
+----------
+
+.. autoclass:: SyntaxNode
+    :members:
+
+
+Nodes
+-----
+
+.. autoclass:: FieldnameNode
+.. autoclass:: TextNode
+.. autoclass:: WordNode
+.. autoclass:: RangeNode
+.. autoclass:: MarkerNode
+
+
+Group nodes
+-----------
+
+.. autoclass:: GroupNode
+.. autoclass:: BinaryGroup
+.. autoclass:: ErrorNode
+.. autoclass:: AndGroup
+.. autoclass:: OrGroup
+.. autoclass:: AndNotGroup
+.. autoclass:: AndMaybeGroup
+.. autoclass:: DisMaxGroup
+.. autoclass:: RequireGroup
+.. autoclass:: NotGroup
+
+
+Operators
+---------
+
+.. autoclass:: Operator
+.. autoclass:: PrefixOperator
+.. autoclass:: PostfixOperator
+.. autoclass:: InfixOperator
+
+
+
+
+
+
+