cpscribe 0.1.0__py3-none-any.whl

cpscribe/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

cpscribe/__main__.py

@@ -0,0 +1,3 @@
+from cpscribe.cli import main
+
+main()

cpscribe/cli.py

@@ -0,0 +1,73 @@
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+from cpscribe import __version__, generator, scraper
+from cpscribe import config as cfg
+
+
+def cmd_init(_args) -> None:
+    cfg.init_interactive()
+
+
+def cmd_post(args) -> None:
+    conf = cfg.load()
+    if not conf["blog_root"]:
+        sys.exit("blog_root not configured -- run `cpscribe init` first")
+
+    if args.input.endswith(".cpp"):
+        cpp_file = Path(args.input)
+        if not cpp_file.exists():
+            sys.exit(f"file not found: {cpp_file}")
+        url = scraper.extract_url_from_cpp(cpp_file.read_text())
+        if not url:
+            sys.exit(f"no Codeforces URL found in {cpp_file}")
+    else:
+        url = args.input
+        cpp_file = Path(args.solution) if args.solution else None
+
+    contest_id, index = scraper.parse_url(url)
+
+    if cpp_file is None:
+        cpp_file = Path(f"{index}.cpp")
+    cpp_code = cpp_file.read_text().strip() if cpp_file.exists() else "// paste your solution here"
+
+    print(f"fetching CF{contest_id}{index}...")
+    problem = scraper.scrape(contest_id, index)
+    print(f"  {index}. {problem['name']}  {problem['rating']}  {problem['contest']}")
+    print(f"  {len(problem['samples'])} sample(s)  {problem['time_lim']}  {problem['mem_lim']}")
+
+    out_dir = Path(conf["blog_root"]) / contest_id
+    out_file = out_dir / f"{index}.md"
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    if out_file.exists() and not args.force:
+        sys.exit(f"already exists: {out_file}  (--force to overwrite)")
+
+    out_file.write_text(generator.build(contest_id, index, problem, cpp_code, conf["author"]))
+    print(f"created: {out_file}")
+
+    editor = args.editor or conf["editor"]
+    if editor:
+        subprocess.Popen([editor, str(out_file)])
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="cpscribe",
+        description="Generate blog posts for competitive programming solutions",
+    )
+    parser.add_argument("-v", "--version", action="version", version=f"cpscribe {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    sub.add_parser("init", help="Configure cpscribe interactively")
+
+    post = sub.add_parser("post", help="Generate a blog post for a Codeforces problem")
+    post.add_argument("input", metavar="URL|file.cpp")
+    post.add_argument("solution", nargs="?", metavar="solution.cpp")
+    post.add_argument("--force", action="store_true", help="overwrite existing post")
+    post.add_argument("--editor", metavar="CMD")
+
+    args = parser.parse_args()
+    {"init": cmd_init, "post": cmd_post}[args.command](args)

cpscribe/config.py

@@ -0,0 +1,49 @@
+import os
+from configparser import ConfigParser
+from pathlib import Path
+
+CONFIG_DIR = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / "cpscribe"
+CONFIG_FILE = CONFIG_DIR / "config"
+
+DEFAULTS: dict[str, str] = {
+    "blog_root": "",
+    "author": "Shravan Goswami",
+    "editor": "subl",
+}
+
+
+def load() -> dict[str, str]:
+    cfg = dict(DEFAULTS)
+    if CONFIG_FILE.exists():
+        parser = ConfigParser()
+        parser.read(CONFIG_FILE)
+        if "cpscribe" in parser:
+            cfg.update(parser["cpscribe"])
+    if v := os.environ.get("CPSCRIBE_BLOG_ROOT"):
+        cfg["blog_root"] = v
+    if v := os.environ.get("CPSCRIBE_AUTHOR"):
+        cfg["author"] = v
+    return cfg
+
+
+def save(cfg: dict[str, str]) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    parser = ConfigParser()
+    parser["cpscribe"] = cfg
+    with open(CONFIG_FILE, "w") as f:
+        parser.write(f)
+
+
+def init_interactive() -> None:
+    cfg = load()
+    print("cpscribe config\n")
+    blog_root = input(f"Blog root [{cfg['blog_root'] or 'required'}]: ").strip()
+    author = input(f"Author [{cfg['author']}]: ").strip()
+    editor = input(f"Editor [{cfg['editor']}]: ").strip()
+    cfg["blog_root"] = blog_root or cfg["blog_root"]
+    cfg["author"] = author or cfg["author"]
+    cfg["editor"] = editor or cfg["editor"]
+    if not cfg["blog_root"]:
+        raise SystemExit("blog_root is required")
+    save(cfg)
+    print(f"\nconfig saved to {CONFIG_FILE}")

cpscribe/generator.py

@@ -0,0 +1,94 @@
+import re
+from datetime import datetime, timezone
+
+
+def _slug(name: str) -> str:
+    return re.sub(r"[^A-Za-z0-9]+", "-", name).strip("-")
+
+
+def _fmt_examples(samples: list[tuple[str, str]]) -> str:
+    if not samples:
+        return "<!-- paste sample inputs/outputs here -->"
+    parts = []
+    for i, (inp, out) in enumerate(samples, 1):
+        label = f"**Example {i}**" if len(samples) > 1 else "**Example**"
+        parts.append(f"{label}\n\nInput:\n```\n{inp}\n```\nOutput:\n```\n{out}\n```")
+    return "\n\n".join(parts)
+
+
+def build(
+    contest_id: str,
+    index: str,
+    problem: dict,
+    cpp_code: str,
+    author: str,
+) -> str:
+    name = problem["name"]
+    rating = problem["rating"]
+    contest = problem["contest"]
+    note_block = f"\n\n### Note\n\n{problem['note']}" if problem.get("note") else ""
+    pub_dt = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    cf_url = f"https://codeforces.com/problemset/problem/{contest_id}/{index}"
+
+    return f"""\
+---
+author: {author}
+pubDatetime: {pub_dt}
+title: "{index}. {name} (CF{contest_id} {rating} RATED)"
+slug: cp/codeforces/{contest_id}/{index}
+tags: [CPP, Codeforces, CF{rating}]
+description: "{index}. {name}, {rating} RATED - {contest}"
+aliases:
+  - /writing/{contest_id}-{index}-{_slug(name)}
+---
+
+Problem Link: [{index}. {name}, {rating} RATED - {contest}]({cf_url})
+
+| Time Limit | Memory Limit |
+| --- | --- |
+| {problem["time_lim"]} | {problem["mem_lim"]} |
+
+## Problem Statement
+
+{problem["body"]}
+
+### Input
+
+{problem["input_spec"]}
+
+### Output
+
+{problem["output_spec"]}{note_block}
+
+## Examples
+
+{_fmt_examples(problem["samples"])}
+
+## My Understanding
+
+<!-- How do you model or restate this problem in your own words? -->
+
+## Key Observations
+
+- <!-- Observation 1 -->
+- <!-- Observation 2 -->
+
+## Approach
+
+<!-- Walk through your full solution strategy -->
+
+## Complexity
+
+- **Time:** $O()$
+- **Space:** $O()$
+
+## Solution
+
+```cpp
+{cpp_code}
+```
+
+## What I Learned
+
+<!-- Key takeaway, trick, or pattern from this problem -->
+"""

cpscribe/scraper.py

@@ -0,0 +1,118 @@
+import re
+import sys
+
+import cloudscraper
+from bs4 import BeautifulSoup, NavigableString
+
+CF_URL_RE = re.compile(
+    r"https://codeforces\.com/(?:contest|problemset/problem)/\d+/(?:problem/)?[A-Za-z]\d*"
+)
+
+
+def parse_url(url: str) -> tuple[str, str]:
+    m = re.search(r"/(?:contest|problemset/problem)/(\d+)/(?:problem/)?([A-Za-z]\d*)", url)
+    if not m:
+        sys.exit(f"could not parse URL: {url}")
+    return m.group(1), m.group(2).upper()
+
+
+def extract_url_from_cpp(text: str) -> str | None:
+    m = CF_URL_RE.search(text)
+    return m.group(0) if m else None
+
+
+def _fix_math(text: str) -> str:
+    return re.sub(r"\$\$\$(.+?)\$\$\$", r"$\1$", text, flags=re.DOTALL)
+
+
+def _node_to_md(node) -> str:
+    if isinstance(node, NavigableString):
+        return _fix_math(str(node))
+    tag = node.name
+    inner = "".join(_node_to_md(c) for c in node.children)
+    match tag:
+        case "p":
+            return inner.strip() + "\n\n"
+        case "strong" | "b":
+            return f"**{inner}**"
+        case "em" | "i":
+            return f"*{inner}*"
+        case "ul" | "ol":
+            return inner
+        case "li":
+            return f"- {inner.strip()}\n"
+        case "br":
+            return "\n"
+        case "div" if "section-title" in node.get("class", []):
+            return ""
+        case _:
+            return inner
+
+
+def _section_md(div) -> str:
+    if not div:
+        return ""
+    return "".join(_node_to_md(c) for c in div.children).strip()
+
+
+def _sample_pre(div) -> str:
+    pre = div.find("pre")
+    if not pre:
+        return ""
+    lines = pre.find_all("div", class_="test-example-line")
+    if lines:
+        return "\n".join(d.get_text() for d in lines).strip()
+    for br in pre.find_all("br"):
+        br.replace_with("\n")
+    return pre.get_text().strip()
+
+
+def scrape(contest_id: str, index: str) -> dict:
+    url = f"https://codeforces.com/problemset/problem/{contest_id}/{index}"
+    resp = cloudscraper.create_scraper().get(url, timeout=15)
+    if resp.status_code != 200:
+        sys.exit(f"problem page returned {resp.status_code}")
+
+    soup = BeautifulSoup(resp.content, "html.parser")
+    ps = soup.find("div", class_="problem-statement")
+
+    header = ps.find("div", class_="header")
+    title_div = header.find("div", class_="title") if header else None
+    name = re.sub(r"^[A-Z]\d*\.\s*", "", title_div.text.strip()) if title_div else "Unknown"
+
+    rating_tag = soup.find("span", class_="tag-box", title="Difficulty")
+    rating = rating_tag.text.strip().replace("*", "") if rating_tag else "Unrated"
+
+    rtable = soup.find("table", class_="rtable")
+    link = rtable.find("a") if rtable else None
+    contest = link.text.strip() if link else f"Codeforces Contest {contest_id}"
+
+    time_tag = soup.find("div", class_="time-limit")
+    mem_tag = soup.find("div", class_="memory-limit")
+    time_lim = time_tag.text.replace("time limit per test", "").strip() if time_tag else "2 seconds"
+    mem_lim = (
+        mem_tag.text.replace("memory limit per test", "").strip() if mem_tag else "256 megabytes"
+    )
+
+    body_div = next((c for c in ps.children if hasattr(c, "get") and not c.get("class")), None)
+
+    samples = []
+    for block in soup.find_all("div", class_="sample-test"):
+        for inp_div, out_div in zip(
+            block.find_all("div", class_="input"),
+            block.find_all("div", class_="output"),
+        ):
+            samples.append((_sample_pre(inp_div), _sample_pre(out_div)))
+
+    return {
+        "name": name,
+        "rating": rating,
+        "contest": contest,
+        "time_lim": time_lim,
+        "mem_lim": mem_lim,
+        "body": _section_md(body_div),
+        "input_spec": _section_md(ps.find("div", class_="input-specification")),
+        "output_spec": _section_md(ps.find("div", class_="output-specification")),
+        "note": _section_md(ps.find("div", class_="note")),
+        "samples": samples,
+    }

cpscribe-0.1.0.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: cpscribe
+Version: 0.1.0
+Summary: Generate blog posts for competitive programming solutions
+Project-URL: Repository, https://github.com/shravanngoswamii/cpscribe
+Project-URL: Issues, https://github.com/shravanngoswamii/cpscribe/issues
+Author-email: Shravan Goswami <contact@shravangoswami.com>
+License: MIT
+License-File: LICENSE
+Keywords: blog,cli,codeforces,competitive-programming
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: beautifulsoup4>=4.12.0
+Requires-Dist: cloudscraper>=1.2.71
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# cpscribe
+
+Generate structured blog posts for Codeforces solutions.
+
+## Install
+
+```sh
+pipx install cpscribe
+```
+
+## Setup
+
+```sh
+cpscribe init
+```
+
+This creates `~/.config/cpscribe/config` with your blog root and author name.
+You can also set `CPSCRIBE_BLOG_ROOT` and `CPSCRIBE_AUTHOR` as environment variables.
+
+## Usage
+
+```sh
+# from a URL
+cpscribe post https://codeforces.com/contest/1903/problem/B
+
+# from a .cpp file with a URL in a comment
+cpscribe post B.cpp
+
+# with an explicit solution file
+cpscribe post https://codeforces.com/contest/1903/problem/B B.cpp
+```
+
+The generated post includes the full problem statement, sample I/O, and structured
+sections for your approach, complexity, solution, and takeaways.
+
+## Update
+
+```sh
+pipx upgrade cpscribe
+```
+
+## License
+
+MIT

cpscribe-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+cpscribe/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+cpscribe/__main__.py,sha256=EUYOOdGKiEr8UCmFelFBMgqdFuqfbp7xtqXCzzUFYXE,38
+cpscribe/cli.py,sha256=0tSwHGTDDu-l-I9wSjxDylV5kdOZtL97OrdSZg1U8Dg,2611
+cpscribe/config.py,sha256=Uf9b_t2lq7rYL5roHczzAEYTtkSJGDA2WIf7nb4IUPo,1472
+cpscribe/generator.py,sha256=VV_QxQZL3LQVRgSsDSVN0LJ467VjWvWTrTTcePOWd4w,2028
+cpscribe/scraper.py,sha256=poj8BGzqnHU41ymqG1PnUuCQW-xMJLqMXEbWFD5OwRc,3909
+cpscribe-0.1.0.dist-info/METADATA,sha256=YpW5tQKdIOTEt4HcEs_PbzFL-08rIXsVTmq-jrb6QmI,1690
+cpscribe-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+cpscribe-0.1.0.dist-info/entry_points.txt,sha256=zv8i3OChkxD2Ah8K__1NcdsndadZpTW4X7jfRH4gp3Y,47
+cpscribe-0.1.0.dist-info/licenses/LICENSE,sha256=KzILKCsAx6H42NOCu2eJASd3ecLwthV9Vy_VoZ4D8LI,1072
+cpscribe-0.1.0.dist-info/RECORD,,

cpscribe-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

cpscribe-0.1.0.dist-info/entry_points.txt

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

cpscribe-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shravan Goswami
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.