writing.com_database / writing.com_server.py
tgdatasets's picture
Upload 4 files
379c0ff verified
Raw History Blame Contribute Delete
44.8 kB
from flask import Flask, request, jsonify, send_file
import sqlite3
import json
import html
from datetime import datetime
import sys
import re
import time
from flask_cors import CORS
app = Flask(__name__, static_folder='.', static_url_path='')
CORS(app)
@app.route('/')
def index():
return send_file('index.html')
@app.route('/reader')
def reader():
return send_file('reader.html')
DB_PATH = "story-database.sqlite"
FTS_SPECIAL_PATTERN = re.compile(r'[()*:+|]|\b(AND|OR|NOT|NEAR)\b', re.IGNORECASE)
# Note: '-' is NOT special here. Hyphenated queries like "The-Golden-Mind-Control"
# are routed through the safe word-splitting path in _build_fts_unit, which treats
# '-' and '_' as word separators so they behave like "The Golden Mind Control".
def get_db_connection():
conn = sqlite3.connect(DB_PATH)
conn.row_factory = sqlite3.Row
# Performance pragmas for the server
conn.execute("PRAGMA mmap_size = 4294967296;") # 4GB mmap
conn.execute("PRAGMA cache_size = 20000;") # Increase cache
# Add REGEXP support
def regexp(expr, item):
if item is None:
return False
reg = re.compile(expr, re.IGNORECASE)
return reg.search(item) is not None
conn.create_function("REGEXP", 2, regexp)
return conn
# Internal Settings
USE_SYNOPSIS_FALLBACK = False # If True, use story["synopsis"] if Intro chapter is missing
def parse_date_to_timestamp(date_str):
if not date_str:
return 0
date_str = date_str.strip()
try:
dt = datetime.strptime(date_str, "%m-%d-%Y")
return int(dt.timestamp())
except:
return 0
def normalize_date_for_sql(date_str, is_before=False):
if not date_str: return None
date_str = date_str.strip('"() ')
if re.match(r'^\d{4}$', date_str):
return f"{date_str}1231" if is_before else f"{date_str}0101"
m = re.match(r'^(\d{1,2})-(\d{1,2})-(\d{4})$', date_str)
if m:
mm = m.group(1).zfill(2)
dd = m.group(2).zfill(2)
yyyy = m.group(3)
return f"{yyyy}{mm}{dd}"
m = re.match(r'^(\d{4})-(\d{1,2})-(\d{1,2})$', date_str)
if m:
yyyy = m.group(1)
mm = m.group(2).zfill(2)
dd = m.group(3).zfill(2)
return f"{yyyy}{mm}{dd}"
return None
def resolve_public_story_id(story_row):
for key in ("url", "url_backup", "extra_url"):
value = story_row[key] if key in story_row.keys() else ""
if not value: continue
match = re.search(r'item_id/(\d+)', value)
if match: return match.group(1)
base_id = str(story_row["base_id"])
leading_digits = re.match(r'^(\d+)', base_id)
return leading_digits.group(1) if leading_digits else base_id
def parse_query_to_groups(raw_query):
if not raw_query: return []
tokens = re.findall(r'"[^"]+"|[^\s|]+|\|', raw_query)
expanded_tokens = []
for t in tokens:
if t == '|':
expanded_tokens.append(t)
continue
is_quoted = t.startswith('"') and t.endswith('"')
inner = t[1:-1] if is_quoted else t
if '|' in inner:
branches = [b.strip() for b in inner.split('|') if b.strip()]
if is_quoted: expanded_tokens.append([f'"{b}"' for b in branches])
else: expanded_tokens.append(branches)
else:
expanded_tokens.append(t)
final_groups = []
i = 0
while i < len(expanded_tokens):
t = expanded_tokens[i]
if t == '|':
i += 1
continue
current_group = t if isinstance(t, list) else [t]
while i + 1 < len(expanded_tokens) and expanded_tokens[i+1] == '|':
i += 2
if i < len(expanded_tokens):
next_t = expanded_tokens[i]
if isinstance(next_t, list): current_group.extend(next_t)
elif next_t != '|': current_group.append(next_t)
else: break
final_groups.append(current_group)
i += 1
return final_groups
def build_fts_query(raw_query):
raw_query = (raw_query or '').strip()
if not raw_query: return ''
if re.search(r'\bAND\b', raw_query, re.IGNORECASE):
tokens = re.findall(r'"[^"]+"|\S+', raw_query)
parts = []
current_part = []
for token in tokens:
if token.upper() == 'AND':
if current_part:
parts.append(" ".join(current_part))
current_part = []
else: current_part.append(token)
if current_part: parts.append(" ".join(current_part))
if len(parts) > 1:
branches = []
for p in parts:
unit = _build_fts_unit(p)
if unit: branches.append(f"({unit})")
if branches: return " AND ".join(branches)
return _build_fts_unit(raw_query)
def _build_fts_unit(raw_query):
raw_query = raw_query.strip()
if not raw_query: return ''
if FTS_SPECIAL_PATTERN.search(raw_query) and '|' not in raw_query: return raw_query
groups = parse_query_to_groups(raw_query)
if not groups: return ''
safe_terms = []
for group in groups:
unit_branches = []
for term in group:
if term.startswith('"') and term.endswith('"') and len(term) >= 2:
phrase = term[1:-1].strip()
if phrase: unit_branches.append(f'"{phrase}"')
continue
cleaned = re.sub(r'[^0-9A-Za-z]+', ' ', term).strip() # '-' and '_' become word separators
if not cleaned: continue
parts = [f'{piece}*' for piece in cleaned.split()]
if parts: unit_branches.append(" ".join(parts))
if unit_branches:
if len(unit_branches) > 1: safe_terms.append("(" + " OR ".join(unit_branches) + ")")
else: safe_terms.append(unit_branches[0])
return ' AND '.join(safe_terms)
def build_like_clause_groups(raw_query):
raw_query = (raw_query or '').strip()
if not raw_query: return []
if re.search(r'\bAND\b', raw_query, re.IGNORECASE):
tokens = re.findall(r'"[^"]+"|\S+', raw_query)
parts = []
current_part = []
for token in tokens:
if token.upper() == 'AND':
if current_part:
parts.append(" ".join(current_part))
current_part = []
else: current_part.append(token)
if current_part: parts.append(" ".join(current_part))
if len(parts) > 1:
res = []
for p in parts: res.extend(parse_query_to_groups(p))
return res
return parse_query_to_groups(raw_query)
def build_like_clause_main(raw_query):
groups = build_like_clause_groups(raw_query)
res = []
for g in groups:
for t in g: res.append(t.strip('"'))
for t in g: res.append(t) # Keep original term, including quotes if present
return list(set(res))
def build_term_pattern(term, prefix_match=False):
"""Compile a regex for a single query term.
Runs of spaces, hyphens ('-') and underscores ('_') are treated as
equivalent separators, so queries typed as "The-Golden-Mind-Control"
or "The_Golden_Mind_Control" match text containing "The Golden Mind
Control" (and any mix of spaces/hyphens/underscores in between).
"""
words = [w for w in re.split(r'[\s_\-]+', term) if w]
if not words: return None
gap = r'[\s_\-]+'
body = gap.join(re.escape(w) for w in words)
pattern = (r'\b' if words[0][0].isalnum() else '') + body
if prefix_match:
pattern += r'\w*' # Prefix match for unquoted terms (aligns with FTS 'word*')
elif words[-1][-1].isalnum():
pattern += r'\b'
return re.compile(pattern, re.IGNORECASE)
def compile_logic(groups):
"""Turn parsed query groups into regexes: one list of patterns per OR group."""
res = []
for group in groups:
pats = []
for p in group:
term = p.strip().lower().strip('"')
if not term: continue
quoted = p.startswith('"') and p.endswith('"')
pat = build_term_pattern(term, prefix_match=not quoted)
if pat: pats.append(pat)
res.append(pats)
return res
def clean_chapter_content(content):
if not content: return ''
text = str(content).strip()
def extract_raw(raw):
if not raw or not isinstance(raw, str): return raw
raw = raw.strip()
if not (raw.startswith('{') or '"html"' in raw):
return raw.replace('\\n', '\n').replace('\\r', '\r')
try:
parsed = json.loads(raw)
if isinstance(parsed, dict) and 'html' in parsed: return extract_raw(parsed['html'])
except: pass
m = re.search(r'"html"\s*:\s*"(.*?)"(?=\s*[,}])', raw, re.DOTALL)
if m:
val = m.group(1).replace('\\"', '"').replace('\\n', '\n').replace('\\r', '\r').replace('\\t', '\t')
return extract_raw(val)
return raw
cleaned = extract_raw(text)
if '<' in cleaned and '>' in cleaned:
cleaned = re.sub(r'(?i)(<br\s*/?>)[\n\r]+', r'\1', cleaned)
cleaned = re.sub(r'(?i)[\n\r]+(<br\s*/?>)', r'\1', cleaned)
block_tags = 'div|p|h[1-6]|ul|ol|li|section|article|blockquote'
cleaned = re.sub(rf'(?i)(</?(?:{block_tags})[^>]*>)[\n\r]+', r'\1', cleaned)
cleaned = re.sub(rf'(?i)[\n\r]+(</?(?:{block_tags})[^>]*>)', r'\1', cleaned)
return cleaned
def extract_search_operator(query_text, operator_name):
pattern = re.compile(rf'{re.escape(operator_name)}(?:\[([^\]]+)\])?:\s*("[^"]+"|\([^)]+\)|\S+)', re.IGNORECASE)
match = pattern.search(query_text or '')
if not match: return None, None, query_text
arg = match.group(1)
value = match.group(2).strip()
cleaned = pattern.sub(' ', query_text, count=1)
cleaned = re.sub(r'\s+', ' ', cleaned).strip()
return value or None, arg, cleaned
def normalize_snippet_text(content):
if not content: return ''
text = clean_chapter_content(content)
text = html.unescape(text)
text = text.replace('\\n', ' ').replace('\\r', ' ').replace('\n', ' ').replace('\r', ' ')
text = re.sub(r'(?i)<br\s*/?>', ' ', text)
text = re.sub(r'(?i)</p\s*>', ' ', text)
text = re.sub(r'(?i)<p[^>]*>', ' ', text)
text = re.sub(r'(?i)</?(i|em|b|strong|u|span|div)[^>]*>', '', text)
text = re.sub(r'<[^>]+>', ' ', text)
text = re.sub(r'\s+', ' ', text).strip()
return text
def highlight_query_terms(snippet, query_parts):
if not snippet: return ''
highlighted = snippet
unique_parts = []
seen = set()
for part in sorted(query_parts or [], key=len, reverse=True):
normalized = part.strip().lower()
if not normalized or normalized in seen: continue
seen.add(normalized)
unique_parts.append(part.strip())
for part in unique_parts:
pattern = build_term_pattern(part, prefix_match=False)
if pattern:
highlighted = pattern.sub(lambda m: f'<mark>{m.group(0)}</mark>', highlighted)
return highlighted
def build_text_match_sql(alias, groups, include_story_fields=False):
if not groups: return "1=1", []
if groups and not isinstance(groups[0], list): groups = [[t] for t in groups]
group_clauses = []
params = []
for group in groups[:8]:
branch_clauses = []
for part in group[:8]:
like_value = f"%{part.strip('\"')}%"
current = [f"{alias}.chapter_title LIKE ?", f"{alias}.chapter_content LIKE ?"]
current_params = [like_value, like_value]
if include_story_fields:
current.extend(["s.title LIKE ?", "s.synopsis LIKE ?"])
current_params.extend([like_value, like_value])
branch_clauses.append("(" + " OR ".join(current) + ")")
params.extend(current_params)
group_clauses.append("(" + " OR ".join(branch_clauses) + ")")
return " AND ".join(group_clauses), params
def make_like_snippet(content, query_parts, radius=200):
if not content: return 'No text preview available.'
text = normalize_snippet_text(content)
unique_parts = sorted(list(set(p.lower().strip('"') for p in query_parts if p.strip())), key=len, reverse=True)
if not unique_parts: return (text[:radius].strip() + "...") if len(text) > radius else text
all_matches = []
for part in unique_parts:
pattern = build_term_pattern(part, prefix_match=False)
if not pattern: continue
for m in pattern.finditer(text):
all_matches.append({'start': m.start(), 'end': m.end(), 'term': part})
if len(all_matches) > 100: break
if not all_matches: return (text[:radius].strip() + "...") if len(text) > radius else text
all_matches.sort(key=lambda x: x['start'])
clusters = []
if all_matches:
curr = {'start': all_matches[0]['start'], 'end': all_matches[0]['end'], 'terms': {all_matches[0]['term']}}
for m in all_matches[1:]:
if m['start'] <= curr['end'] + 60:
curr['end'] = max(curr['end'], m['end'])
curr['terms'].add(m['term'])
else:
clusters.append(curr)
curr = {'start': m['start'], 'end': m['end'], 'terms': {m['term']}}
clusters.append(curr)
for c in clusters:
c['score'] = len(c['terms'])
c['bonus'] = 1.0 / (1.0 + c['start'] / 1000.0)
selected_clusters = []
actual_terms = set(m['term'] for m in all_matches)
remaining_terms = set(unique_parts).intersection(actual_terms)
pool = list(clusters)
while remaining_terms and pool:
best_c = None
max_new_terms = -1
for c in pool:
new_terms = len(c['terms'].intersection(remaining_terms))
if new_terms > max_new_terms:
max_new_terms = new_terms
best_c = c
elif new_terms == max_new_terms and best_c and (c['score'] + c['bonus'] > best_c['score'] + best_c['bonus']):
best_c = c
if best_c and max_new_terms > 0:
selected_clusters.append(best_c)
remaining_terms -= best_c['terms']
pool.remove(best_c)
else: break
if len(selected_clusters) < 4:
clusters.sort(key=lambda x: x['score'] + x['bonus'], reverse=True)
for c in clusters:
if len(selected_clusters) >= 4: break
if any(abs(c['start'] - s['start']) < 80 for s in selected_clusters): continue
selected_clusters.append(c)
selected_clusters.sort(key=lambda x: x['start'])
pieces = []
context_radius = max(20, radius // 8)
for i, c in enumerate(selected_clusters):
w_start = max(0, c['start'] - context_radius)
w_end = min(len(text), c['end'] + context_radius)
if w_start > 0:
space_idx = text.find(' ', w_start, c['start'])
if space_idx != -1: w_start = space_idx + 1
else:
back_space = text.rfind(' ', max(0, w_start - 20), w_start)
if back_space != -1: w_start = back_space + 1
if w_end < len(text):
space_idx = text.rfind(' ', c['end'], w_end)
if space_idx != -1: w_end = space_idx
else:
fwd_space = text.find(' ', w_end, min(len(text), w_end + 20))
if fwd_space != -1: w_end = fwd_space
if i > 0 and w_start < selected_clusters[i-1]['end_display']: w_start = selected_clusters[i-1]['end_display']
if w_start >= w_end: continue
piece = text[w_start:w_end]
prefix = "... " if w_start > 0 else ""
suffix = " ..." if w_end < len(text) else ""
pieces.append(f"{prefix}{piece.strip()}{suffix}")
c['end_display'] = w_end
snippet = "".join(pieces)
snippet = re.sub(r'\.\.\.\s*\.\.\.', '...', snippet)
snippet = re.sub(r'\.\.\.\.\.\.', '...', snippet)
snippet = re.sub(r'\s+', ' ', snippet)
return highlight_query_terms(snippet.strip(), query_parts)
@app.route('/api/story/<base_id>', methods=['GET'])
def get_story(base_id):
if base_id.endswith('.html'): base_id = base_id[:-5]
conn = get_db_connection()
story = conn.execute("SELECT * FROM stories WHERE base_id = ?", (base_id,)).fetchone()
actual_chapter_id = None
if not story:
cid_match = conn.execute("SELECT base_id, map_id FROM chapters WHERE map_id LIKE ?", (f"%-{base_id}",)).fetchone()
if cid_match:
actual_story_id = cid_match["base_id"]
actual_chapter_id = cid_match["map_id"].split("-", 1)[1] if "-" in cid_match["map_id"] else cid_match["map_id"]
story = conn.execute("SELECT * FROM stories WHERE base_id = ?", (actual_story_id,)).fetchone()
if not story:
cid_search = f"%{base_id}%"
story_match = conn.execute("SELECT * FROM stories WHERE url LIKE ? OR image LIKE ?", (cid_search, cid_search)).fetchone()
if story_match: story = story_match
if not story:
conn.close()
return jsonify({'error': 'Story not found'}), 404
base_id = story["base_id"]
chapters_raw = conn.execute("SELECT * FROM chapters WHERE base_id = ?", (base_id,)).fetchall()
conn.close()
public_story_id = resolve_public_story_id(story)
story_data = {
"info": {
"id": public_story_id, "pretty_title": story["title"], "description": story["synopsis"] if USE_SYNOPSIS_FALLBACK else "",
"author_name": story["author_name"] if "author_name" in story.keys() else story["authorcutename"],
"author_id": story["author_raw_name"] if "author_raw_name" in story.keys() else story["authorid"],
"created": parse_date_to_timestamp(story["date"]), "source_url": story["url"] if "url" in story.keys() else "",
"resolved_chapter_id": actual_chapter_id
}, "chapters": {}
}
for c in chapters_raw:
full_map_id = c["map_id"]
parts = full_map_id.split("-", 1)
suffix = parts[1] if len(parts) > 1 else full_map_id
choices_list = []
if c["choices"]:
for choice_str in c["choices"].split("||||"):
cleaned = re.sub(r'^\d+\.\s*', '', choice_str.strip())
if cleaned: choices_list.append(cleaned)
html_content = clean_chapter_content(c["chapter_content"])
if suffix == 'Intro': story_data["info"]["description"] = html_content
story_data["chapters"][suffix] = {
"id": c["map_id"], "title": c["chapter_title"], "content": html_content,
"created": parse_date_to_timestamp(c["date"]), "choices": choices_list,
"author_name": c["author_name"] if "author_name" in c.keys() else story["authorcutename"],
"author_id": c["author_raw_name"] if "author_raw_name" in c.keys() else story["authorid"]
}
return jsonify(story_data)
@app.route('/api/author/<authorid>', methods=['GET'])
def get_by_author(authorid):
conn = get_db_connection()
try: stories = conn.execute("SELECT * FROM stories WHERE author_raw_name = ?", (authorid,)).fetchall()
except sqlite3.OperationalError: stories = conn.execute("SELECT * FROM stories WHERE authorid = ?", (authorid,)).fetchall()
conn.close()
return jsonify([dict(s) for s in stories])
@app.route('/api/author_chapters/<authorid>', methods=['GET'])
def get_author_chapters(authorid):
page, limit = int(request.args.get('page', 1)), int(request.args.get('limit', 500))
query, offset = request.args.get('q', '').strip(), (page - 1) * limit
sort = request.args.get('sort', 'date-desc')
date_sort_expr = "substr(c.date, 7, 4) || substr(c.date, 1, 2) || substr(c.date, 4, 2)"
order_map = {'date-asc': f"{date_sort_expr} ASC", 'title-asc': "c.chapter_title ASC", 'title-desc': "c.chapter_title DESC"}
order_by = order_map.get(sort, f"{date_sort_expr} DESC")
conn = get_db_connection()
try:
if query:
count_res = conn.execute("SELECT COUNT(*) FROM chapters_fts f JOIN chapters c ON f.rowid = c.id WHERE c.author_raw_name = ? AND chapters_fts MATCH ?", (authorid, query)).fetchone()
total_count = count_res[0]
results = conn.execute(f"SELECT c.map_id, c.base_id, c.chapter_title, c.chapter_content, c.date as created, s.title as story_title, c.author_name as author_name FROM chapters_fts f JOIN chapters c ON f.rowid = c.id JOIN stories s ON c.base_id = s.base_id WHERE c.author_raw_name = ? AND chapters_fts MATCH ? ORDER BY (c.chapter_content IS NULL OR c.chapter_content = '' OR c.chapter_content = '{{}}') ASC, {order_by} LIMIT ? OFFSET ?", (authorid, query, limit, offset)).fetchall()
else:
count_res = conn.execute("SELECT COUNT(*) FROM chapters WHERE author_raw_name = ?", (authorid,)).fetchone()
total_count = count_res[0]
results = conn.execute(f"SELECT c.map_id, c.base_id, c.chapter_title, c.chapter_content, c.date as created, s.title as story_title, c.author_name as author_name FROM chapters c JOIN stories s ON c.base_id = s.base_id WHERE c.author_raw_name = ? ORDER BY (c.chapter_content IS NULL OR c.chapter_content = '' OR c.chapter_content = '{{}}') ASC, {order_by} LIMIT ? OFFSET ?", (authorid, limit, offset)).fetchall()
except:
count_res = conn.execute("SELECT COUNT(*) FROM stories WHERE authorid = ?", (authorid,)).fetchone()
total_count = count_res[0]
results = conn.execute("SELECT c.map_id, c.base_id, c.chapter_title, c.chapter_content, c.date as created, s.title as story_title, s.authorcutename as author_name FROM chapters c JOIN stories s ON c.base_id = s.base_id WHERE s.authorid = ? ORDER BY c.date DESC LIMIT ? OFFSET ?", (authorid, limit, offset)).fetchall()
conn.close()
return jsonify({'chapters': [{**dict(r), 'chapter_content': clean_chapter_content(r['chapter_content'])} for r in results], 'total': total_count, 'page': page, 'limit': limit, 'query': query})
CATEGORIES = {
"Fanfic Stories": {"title_only": "Isekai|Konosuba|Kanto's Ghost|Scooby-Doo|Genshin Impact|Assassin's Creed|The Highschool|Persona|Yugi Moto|Yu-Yi-Yh|My hero academia|X-Men|VTubers|Disney|X Men|Lion King|Ace Attorney|Fanfic Stories|Tails|My little pony|TV Series Change/Transform|Anime", "general_search": "Tomb Raider|Code Geass|Dinotopia|Dragon Quest|Big Bang Theory|dragonball Z|Ace Attorney|Super Smash Bros|Yaoi Cartoon|Ben 10|Alex Russo|Isekai|KirbyKnights|NRDD|Zootopia|Simpson's|Sakura Wars|Ranma|Ben & Gwen|Yu Gi Oh|Simpsons|Ranma 1/2|Sailor Moon|Naruto|Power Rangers|Heroes|Sonic|Rugrats|RWBY|My Little Poney|dragon ball|digimon|hentai|Harry Potter|Scooby doo|Wonder Woman|Mass Effect|Family Guy|Wizards of Waverly Place|Pokegirls|Pokemorph|pokémon|pokemon|poke-dex|pokéflute|pokemons|pokémons|pikachu|pokechange|mario|wario|Zelda|Princess Zelda|Maburaho|Yu-gi-oh|yugioh|Yu-Gi-Oh|DC cinematic universe|Marvel|Marvel's|superhero|super heroine|Star Fox|Batman|Spider-Man|X-Men Evolution|Final Fantasy|Star Trek|Star Wars|icarly|Sherlock Holmes"},
"Role Swap": {"title_only": "", "general_search": "trading places|gender swap|role swap|life swap|switch roles|switched roles|swaps roles|swapped roles|swapped places|trade lives|switch lives|trade palces|trading places|swapping places|swapping roles|switching places|role reversal|swap roles"},
"Body Parts Swap": {"title_only": "", "general_search": "head swap|head swapping"},
"Body Swap": {"title_only": "", "general_search": "swapping bodies|transplant|bodyswap|body swap|body switch|switch bodies|switched bodies|swaps bodies|swap bodies|swapped bodies"},
"Giant/Expanasion/Growth Fetish": {"title_only": "Colossal|Growing Boy|titans|Muscle|Big Little Girls|Giantess|BIG GIRLS|Fatties|Growth|Expansion|Growth|Grew|Giant|Male Giant|Weight|Fat|Expansion|Size|Expansions|Big Girls|GTS|Big Boys|giant animals|get fat|muscle growth|expansion stories|fat girls", "general_search": "muscle growth|expansion stories|Macrophiles|Giantess Island|giant-ess|giant guys|giantess|amazonian|amazonians|Amazon Invasion|Female Growth |giants|giant's house|female expansion|female expansions|male expansions|women gain weight|fat disney|gts|weight gaining|women expand|wwe|weight gain|gts|gt/wg|weight gaining|weighty women|fatties|growing girls|size story|big fat|feet growth|size ray|giant kids|giant men"},
"Shrink Fetish": {"title_only": "Short Life|Tiny|Shrink|Shrunk", "general_search": "Small Town Swaps|shrinkgrowth|shrinking|shrunken|shruken|shrink ray|tiny life"},
"Feet Fetish": {"title_only": "Foot|Feet", "general_search": "teen feet|feet growth|foot fetish|footslave|teen feet|girl feet|female feet"},
"Vore": {"title_only": "", "general_search": "vore|vorarephilia|cannibal|cockvore|cartoon vore"},
"Tights/Pantyhose Fetish": {"title_only": "", "general_search": "tights|pantyhose|nylon|stockings|hosery|nylons"},
"Adult Baby": {"title_only": "", "general_search": "ABDL|ab-dl|adult baby|adult babies|diapers|diaper|diaperpalooza"},
"Ticklish": {"title_only": "", "general_search": "Tickling Women|ticklish|tickle|tickles|tickle feetish"},
"Fart": {"title_only": "fart|smelly", "general_search": ""},
"Furry": {"title_only": "", "general_search": "furry|furries|Zootopia|muscle growth|expansion stories"},
"Gay": {"title_only": "Gay|LGBTQ+", "general_search": ""}
}
@app.route('/api/stories', methods=['GET'])
def get_stories():
page, limit = int(request.args.get('page', 1)), int(request.args.get('limit', 100))
offset, q = (page - 1) * limit, request.args.get('q', '').strip()
sort = request.args.get('sort', 'created_desc')
include_cats = [c for c in request.args.get('categories', '').split(',') if c]
exclude_cats = [c for c in request.args.get('exclude_categories', '').split(',') if c]
conn = get_db_connection()
where_clauses, params = [], []
if q:
where_clauses.append("(base_id LIKE ? OR title LIKE ? OR synopsis LIKE ? OR author_name LIKE ? OR author_raw_name LIKE ?)")
lq = f"%{q}%"
params.extend([lq, lq, lq, lq, lq])
for cat_name in include_cats:
if cat_name in CATEGORIES:
cat = CATEGORIES[cat_name]
clauses = []
if cat["title_only"]: clauses.append("title REGEXP ?"); params.append(cat["title_only"])
if cat["general_search"]: clauses.append("(title REGEXP ? OR synopsis REGEXP ?)"); params.extend([cat["general_search"], cat["general_search"]])
if clauses: where_clauses.append("(" + " OR ".join(clauses) + ")")
for cat_name in exclude_cats:
if cat_name in CATEGORIES:
cat = CATEGORIES[cat_name]
if cat["title_only"]: where_clauses.append("NOT (title REGEXP ?)"); params.append(cat["title_only"])
if cat["general_search"]: where_clauses.append("NOT (title REGEXP ? OR synopsis REGEXP ?)"); params.extend([cat["general_search"], cat["general_search"]])
where_sql = " WHERE " + " AND ".join(where_clauses) if where_clauses else ""
count_res = conn.execute(f"SELECT COUNT(*) FROM stories {where_sql}", params).fetchone()
total_count = count_res[0]
sort_map = {'title_asc': 'title ASC', 'title_desc': 'title DESC', 'chapters_desc': 'chapter_count DESC', 'chapters_asc': 'chapter_count ASC', 'created_desc': 'date DESC', 'created_asc': 'date ASC', 'modified_desc': 'last_modified DESC', 'modified_asc': 'last_modified ASC'}
order_by = sort_map.get(sort, 'date DESC')
results = conn.execute(f"SELECT base_id as id, title, author_name as authorcutename, author_raw_name as authorid, synopsis, date, chapter_count as chapterCount, last_modified as lastmodified FROM stories {where_sql} ORDER BY {order_by} LIMIT ? OFFSET ?", params + [limit, offset]).fetchall()
conn.close()
return jsonify({'stories': [dict(r) for r in results], 'total': total_count, 'page': page, 'limit': limit})
@app.route('/api/author_contributions/<authorid>', methods=['GET'])
def get_author_contributions(authorid):
page, limit = int(request.args.get('page', 1)), int(request.args.get('limit', 100))
sort = request.args.get('sort', 'date-desc')
offset = (page - 1) * limit
conn = get_db_connection()
# Sort mapping
date_sort_expr = "substr(s.date, 7, 4) || substr(s.date, 1, 2) || substr(s.date, 4, 2)"
sort_map = {
'date-desc': f"{date_sort_expr} DESC",
'date-asc': f"{date_sort_expr} ASC",
'contrib-desc': "contribution_count DESC, " + date_sort_expr + " DESC",
'contrib-asc': "contribution_count ASC, " + date_sort_expr + " DESC"
}
order_by = sort_map.get(sort, f"{date_sort_expr} DESC")
# Find unique base_ids where author wrote a chapter, and join with stories metadata
query = f"""
SELECT s.base_id as id, s.title, s.author_name as authorcutename, s.author_raw_name as authorid,
s.synopsis, s.date, s.chapter_count as chapterCount, s.last_modified as lastmodified,
COUNT(c.map_id) as contribution_count
FROM stories s
JOIN chapters c ON s.base_id = c.base_id
WHERE c.author_raw_name = ?
GROUP BY s.base_id
ORDER BY {order_by}
LIMIT ? OFFSET ?
"""
results = conn.execute(query, (authorid, limit, offset)).fetchall()
count_query = "SELECT COUNT(DISTINCT base_id) FROM chapters WHERE author_raw_name = ?"
total_count = conn.execute(count_query, (authorid,)).fetchone()[0]
conn.close()
return jsonify({'stories': [dict(r) for r in results], 'total': total_count, 'page': page, 'limit': limit})
@app.route('/api/related_authors/<authorid>', methods=['GET'])
def get_related_authors(authorid):
filter_type, limit = request.args.get('filter', 'general'), int(request.args.get('limit', 50))
conn = get_db_connection()
where_clause = "WHERE c1.author_raw_name = ? AND c2.author_raw_name != ? AND c2.author_raw_name IS NOT NULL AND c2.author_raw_name != '' AND c2.author_name IS NOT NULL AND c2.author_name != '' AND LOWER(c2.author_name) != 'unknown' AND LOWER(c2.author_raw_name) != 'unknown' AND c2.map_id LIKE c1.map_id || '%'"
if filter_type == 'recent':
one_year_ago = (datetime.now().year - 1) * 10000 + datetime.now().month * 100 + datetime.now().day
where_clause += f" AND (substr(c1.base_id, 1, 0) || (SELECT (substr(s.date, 7, 4) || substr(s.date, 1, 2) || substr(s.date, 4, 2)) FROM stories s WHERE s.base_id = c1.base_id)) >= '{one_year_ago}'"
results = conn.execute(f"SELECT c2.author_name as name, c2.author_raw_name as id, COUNT(*) as follow_ups FROM chapters c1 JOIN chapters c2 ON c1.base_id = c2.base_id {where_clause} GROUP BY c2.author_raw_name ORDER BY follow_ups DESC LIMIT ?", (authorid, authorid, limit)).fetchall()
conn.close()
return jsonify([dict(r) for r in results])
@app.route('/api/search', methods=['GET'])
def search():
start_time = time.time()
q = request.args.get('q', '')
if not q: return jsonify([])
page, limit = max(1, int(request.args.get('page', 1))), max(1, min(1000, int(request.args.get('limit', 100))))
offset = (page - 1) * limit
include_cats = [c for c in request.args.get('categories', '').split(',') if c]
exclude_cats = [c for c in request.args.get('exclude_categories', '').split(',') if c]
snippet_limit = max(50, min(5000, int(request.args.get('snippet_limit', 300))))
related_snippet_limit = max(50, min(5000, int(request.args.get('related_snippet_limit', 300))))
clean_query = q
author_filter, _, clean_query = extract_search_operator(clean_query, 'author')
if author_filter: author_filter = author_filter.strip('"()')
story_filter, _, clean_query = extract_search_operator(clean_query, 'storyID')
if story_filter: story_filter = story_filter.strip('"()')
related_filter, related_depth_str, clean_query = extract_search_operator(clean_query, 'relatedsearch')
related_depth_limit = int(related_depth_str) if related_depth_str and related_depth_str.isdigit() else None
before_filter, _, clean_query = extract_search_operator(clean_query, 'before')
after_filter, _, clean_query = extract_search_operator(clean_query, 'after')
date_sort_expr = "substr(c.date, 7, 4) || substr(c.date, 1, 2) || substr(c.date, 4, 2)"
before_val, after_val = normalize_date_for_sql(before_filter, True), normalize_date_for_sql(after_filter, False)
fts_query = build_fts_query(clean_query)
query_parts, query_groups = build_like_clause_main(clean_query), parse_query_to_groups(clean_query)
related_parts, related_groups = build_like_clause_main(related_filter or ''), parse_query_to_groups(related_filter or '')
# Category optimization
comb_inc_t = "|".join([CATEGORIES[c]["title_only"] for c in include_cats if c in CATEGORIES and CATEGORIES[c]["title_only"]])
comb_inc_g = "|".join([CATEGORIES[c]["general_search"] for c in include_cats if c in CATEGORIES and CATEGORIES[c]["general_search"]])
comb_exc_t = "|".join([CATEGORIES[c]["title_only"] for c in exclude_cats if c in CATEGORIES and CATEGORIES[c]["title_only"]])
comb_exc_g = "|".join([CATEGORIES[c]["general_search"] for c in exclude_cats if c in CATEGORIES and CATEGORIES[c]["general_search"]])
conn = get_db_connection()
all_matching_results, current_search_offset, max_scan_total, rows_scanned, total = [], 0, 100000, 0, 0
results_to_skip, target_limit = offset, limit
if fts_query:
try:
where_clauses, params = ["chapters_fts MATCH ?"], [fts_query]
if comb_inc_t: where_clauses.append("(s.title REGEXP ? OR c.chapter_title REGEXP ?)"); params.extend([comb_inc_t, comb_inc_t])
if comb_inc_g: where_clauses.append("(s.title REGEXP ? OR c.chapter_title REGEXP ? OR s.synopsis REGEXP ?)"); params.extend([comb_inc_g, comb_inc_g, comb_inc_g])
if comb_exc_t: where_clauses.append("NOT (s.title REGEXP ? OR c.chapter_title REGEXP ?)"); params.extend([comb_exc_t, comb_exc_t])
if comb_exc_g: where_clauses.append("NOT (s.title REGEXP ? OR c.chapter_title REGEXP ? OR s.synopsis REGEXP ?)"); params.extend([comb_exc_g, comb_exc_g, comb_exc_g])
if author_filter: where_clauses.append("(c.author_raw_name LIKE ? OR c.author_name LIKE ?)"); params.extend([f"%{author_filter}%", f"%{author_filter}%"])
if story_filter: where_clauses.append("c.base_id = ?"); params.append(story_filter)
if before_val: where_clauses.append(f"{date_sort_expr} <= ?"); params.append(before_val)
if after_val: where_clauses.append(f"{date_sort_expr} >= ?"); params.append(after_val)
if related_groups:
related_fts = build_fts_query(related_filter)
where_clauses.append("c.base_id IN (SELECT DISTINCT c_rel.base_id FROM chapters_fts f_rel JOIN chapters c_rel ON f_rel.rowid = c_rel.id WHERE f_rel.chapters_fts MATCH ?)")
params.append(related_fts)
where_sql = " AND ".join(where_clauses)
count_start = time.time()
total = conn.execute(f"SELECT COUNT(*) FROM chapters_fts JOIN chapters c ON chapters_fts.rowid = c.id JOIN stories s ON c.base_id = s.base_id WHERE {where_sql}", params).fetchone()[0]
print(f"[*] Incoming Search: '{q}'")
print(f"[*] FTS matches to verify: {total} (Count took {time.time()-count_start:.2f}s)")
compiled_patterns = compile_logic(query_groups)
rel_compiled_patterns = compile_logic(related_groups)
related_cache = {}
# Pre-calculate related FTS query once to avoid overhead in the loop
rel_fts_val = build_fts_query(related_filter) if related_filter else None
while len(all_matching_results) < target_limit and rows_scanned < max_scan_total:
# Increase batch size if hit rate is low to reduce SQL roundtrips
fetch_batch_size = 500 if rows_scanned > 1000 and not all_matching_results else max(target_limit, 200)
if rows_scanned % 200 == 0 or rows_scanned == 0:
print(f"[*] Progress: {rows_scanned}/{total} scanned | {len(all_matching_results)} hits | {len(related_cache)} stories cached")
batch = conn.execute(f"SELECT c.map_id, c.base_id, c.chapter_title, c.chapter_content, s.title as story_title, s.synopsis, c.author_name, c.author_raw_name, c.date as created, (SELECT MAX(LENGTH(c2.map_id)) - LENGTH(c.map_id) FROM chapters c2 WHERE c2.base_id = c.base_id AND c2.map_id LIKE c.map_id || '%') as ldfh FROM chapters_fts JOIN chapters c ON chapters_fts.rowid = c.id JOIN stories s ON c.base_id = s.base_id WHERE {where_sql} ORDER BY rank, c.id DESC LIMIT ? OFFSET ?", params + [fetch_batch_size, current_search_offset]).fetchall()
if not batch: break
for row in batch:
rows_scanned += 1
row_dict = dict(row)
meta_text = f"{row_dict.get('chapter_title') or ''} {row_dict.get('story_title') or ''} {row_dict.get('synopsis') or ''}".lower()
match_all, unmatched = True, []
for group_pats in compiled_patterns:
if not any(pat.search(meta_text) for pat in group_pats): unmatched.append(group_pats)
if unmatched:
clean_content = clean_chapter_content(row_dict.get('chapter_content'))
content_low = html.unescape(re.sub(r'<[^>]+>', ' ', clean_content)).lower()
for group_pats in unmatched:
if not any(pat.search(content_low) for pat in group_pats): match_all = False; break
else: clean_content = None
if match_all and related_filter:
bid = row_dict['base_id']
if bid not in related_cache:
try:
rel_rows = conn.execute(f"SELECT c.base_id, c.map_id, c.chapter_title, c.chapter_content, c.author_name, c.author_raw_name, c.date as created, (SELECT MAX(LENGTH(c2.map_id)) - LENGTH(c.map_id) FROM chapters c2 WHERE c2.base_id = c.base_id AND c2.map_id LIKE c.map_id || '%') as ldfh FROM chapters_fts f JOIN chapters c ON f.rowid = c.id WHERE c.base_id = ? AND f.chapters_fts MATCH ?", (bid, rel_fts_val)).fetchall()
processed_rel = []
for rr in rel_rows:
rd = dict(rr)
# Lightweight cleaning for search text: just strip HTML tags and unescape
raw_text = f"{rd.get('chapter_title') or ''} {rd.get('chapter_content') or ''}"
rd['_search_text'] = html.unescape(re.sub(r'<[^>]+>', ' ', raw_text)).lower()
processed_rel.append(rd)
related_cache[bid] = processed_rel
except: related_cache[bid] = []
m_map, m_suf = row_dict['map_id'], (row_dict['map_id'].split('-')[1] if '-' in row_dict['map_id'] else "").replace("Intro", "")
valid_related = []
for rr in related_cache[bid]:
r_suf = (rr['map_id'].split('-')[1] if '-' in rr['map_id'] else "").replace("Intro", "")
if related_depth_limit is not None and (not (r_suf.startswith(m_suf) or m_suf.startswith(r_suf)) or abs(len(r_suf)-len(m_suf)) > related_depth_limit): continue
rr_txt = rr['_search_text']
rel_match_all, matched_terms = True, []
for grp_idx, grp_pats in enumerate(rel_compiled_patterns):
grp_matched = False
for pat_idx, pat in enumerate(grp_pats):
if pat.search(rr_txt):
grp_matched = True
matched_terms.append(related_groups[grp_idx][pat_idx].strip('"'))
if not grp_matched:
rel_match_all = False
break
if not rel_match_all: continue
rr_copy = dict(rr)
rr_copy['matched_terms_found'] = list(set(matched_terms))
valid_related.append(rr_copy)
if not valid_related: match_all = False
else: row_dict['related_matches_pre'] = valid_related[:20]
if match_all:
if results_to_skip > 0: results_to_skip -= 1
else:
if clean_content is None: clean_content = clean_chapter_content(row_dict.get('chapter_content'))
row_dict['chapter_content_clean'] = clean_content
row_dict['content_text'] = normalize_snippet_text(clean_content)
all_matching_results.append(row_dict)
if len(all_matching_results) >= target_limit: break
current_search_offset += fetch_batch_size
if len(batch) < fetch_batch_size: break
scanned_all = (len(all_matching_results) < target_limit) and (rows_scanned < max_scan_total)
if scanned_all:
total = (offset - results_to_skip) + len(all_matching_results)
except Exception as e:
print(f"Error during search: {e}")
all_matching_results, total = [], 0
final_results = []
def part_in_text(part, text):
if not text: return False
pat = build_term_pattern(part.strip('"'), prefix_match=False)
return bool(pat and pat.search(text))
for row_dict in all_matching_results[:limit]:
content, synopsis = row_dict.get('chapter_content_clean') or "", row_dict.get('synopsis') or ""
text_source = content if any(part_in_text(p, row_dict.get('content_text') or "") for p in query_parts) else (synopsis if any(part_in_text(p, synopsis) for p in query_parts) else (content or synopsis))
row_dict['snippet'] = make_like_snippet(text_source, query_parts, radius=snippet_limit)
row_dict['chapter_title'] = highlight_query_terms(row_dict.get('chapter_title') or "", query_parts)
row_dict['story_title'] = highlight_query_terms(row_dict.get('story_title') or "", query_parts)
for k in ['chapter_content', 'chapter_content_clean', 'content_text', 'synopsis']: row_dict.pop(k, None)
final_results.append(row_dict)
if final_results and related_filter:
for res in final_results:
pre_matches = res.pop('related_matches_pre', [])
res['related_matches'] = []
for rr in pre_matches:
res['related_matches'].append({
"map_id": rr["map_id"], "title": rr["chapter_title"],
"snippet": make_like_snippet(rr["chapter_content"], related_parts, radius=related_snippet_limit),
"author_name": rr["author_name"], "author_raw_name": rr["author_raw_name"],
"created": rr["created"], "matched_terms": rr.get('matched_terms_found', []), "ldfh": rr["ldfh"]
})
conn.close()
duration = time.time() - start_time
print(f"[*] Search complete in {duration:.2f}s. Results found: {len(final_results)}.")
return jsonify({'results': final_results, 'total': total, 'page': page, 'limit': limit, 'query': q, 'duration': duration})
if __name__ == '__main__': app.run(host='0.0.0.0', port=9999, debug=True)