Spaces:
Running
Running
unknown
Claude Opus 5.5
Smart Humanize: "What should come down?" - Lower the AI score / Reduce similarity / Both. Reduce similarity rewords the sentences a similarity report matched (an uploaded report is read as a similarity report), or without a report every prose sentence, each until at most 15% of its original word sequences remain (citations, numbers, terms and layout kept, meaning checked), and still takes the AI score to 0%; the result says how much original wording remains. The Turnitin "Lower it" / "Reduce it" buttons set the goal. Goal choice styled in the Manuscript-desk look; intro mentions similarity
7bfa845 | """Yearly plans, the usage-based price of a job, locked results and the automatic proofread (no models, no network).""" | |
| import os | |
| import tempfile | |
| import pytest | |
| os.environ.setdefault("USERS_DB", os.path.join(tempfile.gettempdir(), "cs_suite_test_users.db")) | |
| app = pytest.importorskip("app") | |
| P, D, S, H = app.P, app.D, app.S, app.H | |
| TEXT = ("The model was trained on the full dataset of 12,500 images and it reached an accuracy of 96.3% [4]. " | |
| "The results were compared with a baseline that used the same data and the same split of the samples.") | |
| def _docx(tmp_path, name="paper.docx", text=TEXT): | |
| from docx import Document | |
| d = Document() | |
| d.add_paragraph(text) | |
| p = tmp_path / name | |
| d.save(str(p)) | |
| return str(p) | |
| # ---------------------------------------------------------------- yearly plans | |
| def test_yearly_is_twelve_months_less_the_discount(): | |
| assert P.YEARLY_DISCOUNT == 20 | |
| assert P.yearly_amount("scholar", "INR") == 9590 # 12 x 999 x 0.8, to the nearest ten rupees | |
| assert P.yearly_amount("pro", "INR") == 28790 | |
| assert P.yearly_amount("scholar", "USD") == 134 | |
| labels = P.price_buttons("INR") | |
| assert len(labels) == len(P.BUY_ITEMS) == 6 | |
| assert "₹9,590/year" in labels[4] and "₹28,790/year" in labels[5] | |
| assert "a year (save 20%)" in P.pricing_html("INR") | |
| # ---------------------------------------------------------------- usage-based price | |
| def test_price_is_cost_plus_margin_plus_gst(): | |
| p = P.usage_price(300, 0.20) # 5 minutes of GPU, 20 cents of language model | |
| assert p["gpu_usd"] == pytest.approx(300 * 0.40 / 3600) | |
| assert p["space_usd"] == pytest.approx(p["gpu_usd"] * 4) # idle share of the always-on Space | |
| assert p["cost_usd"] == pytest.approx(p["gpu_usd"] * 5 + 0.20) | |
| assert p["profit_usd"] == pytest.approx(4 * p["cost_usd"]) # 400% margin: price before tax = 5 x cost | |
| assert p["gst_usd"] == pytest.approx(0.18 * 5 * p["cost_usd"]) | |
| assert p["inr"] == 184 # $2.164 x 85, rounded up | |
| assert P.usage_price(1, 0)["inr"] == P.PRICE_MIN_INR # never below the smallest charge | |
| def test_no_credits_means_the_wallet_pays_not_a_block(monkeypatch): | |
| free = dict(admin=False, key="free", credits=0, trial_left=0, doc_words=5000, status="free", docs_month=0, | |
| used=0, month_end=None) | |
| monkeypatch.setattr(P, "state", lambda user: dict(free)) | |
| monkeypatch.setattr(P, "docs_available", lambda st: 0) | |
| monkeypatch.setattr(P, "_free_rerun", lambda e, fkey: False) | |
| assert P.check_doc({"email": "a@b.co"}, 4000, "Smart Humanize") == "wallet" # paid from the prepaid wallet | |
| monkeypatch.setattr(P, "PAY_PER_USE", False) | |
| with pytest.raises(app.A.Upsell): | |
| P.check_doc({"email": "a@b.co"}, 4000, "Smart Humanize") | |
| # ---------------------------------------------------------------- charges, the pop-up, unlocking | |
| def test_charge_is_locked_until_it_is_settled(tmp_path, monkeypatch): | |
| out = _docx(tmp_path, "paper_humanized.docx") | |
| tok = app.PAYG_FOR.set("payer@example.com") | |
| monkeypatch.setattr(S.G, "spent", lambda book=None: 0.20) | |
| try: | |
| c = app._payg_lock(out, "Smart Humanize", "paper.docx", 4000, 300, None) | |
| finally: | |
| app.PAYG_FOR.reset(tok) | |
| assert c["status"] == "pending" and c["amount_inr"] == 184 and c["ref"].startswith("CS-") | |
| user = {"email": "payer@example.com"} | |
| status, file, dl = app.claim_paid(user) | |
| assert "not confirmed yet" in status and "Pay now" in status and not isinstance(file, str) | |
| ok, msg = P.settle_charge(c["ref"], source="admin") | |
| assert ok and "can now download" in msg | |
| status, file, dl = app.claim_paid(user) | |
| assert "Payment received" in status and file == out and "Download" in dl | |
| assert P.settle_charge(c["ref"])[1].endswith("already paid.") | |
| assert P.settle_charge("CS-NOPE")[0] is False | |
| def test_nothing_is_locked_for_a_job_covered_by_a_plan(tmp_path): | |
| assert app.PAYG_FOR.get() is None | |
| assert app._payg_lock(_docx(tmp_path), "Smart Humanize", "paper.docx", 4000, 300, None) is None | |
| def test_popup_shows_the_price_and_opens_the_payment_page(monkeypatch): | |
| c = dict(ref="CS-ABCD1234", name="thesis.docx", words=5120, amount_inr=111.0, tool="Smart Humanize", | |
| email="payer@example.com") | |
| monkeypatch.setattr(P, "PAY_URL", "https://pay.example.com/p?amount={amount}&ref={ref}&email={email}") | |
| h = app.pay_popup_html(c, "smart") | |
| assert 'class="cs-upsell' in h and "₹111" in h and "CS-ABCD1234" in h and "18% GST" in h | |
| assert 'href="https://pay.example.com/p?amount=111&ref=CS-ABCD1234&email=payer%40example.com"' in h | |
| assert 'target="_blank"' in h and 'data-cs-go="cs-go-unlock-smart"' in h | |
| monkeypatch.setattr(P, "PAY_URL", "") # no gateway yet: the WhatsApp contact | |
| assert "https://wa.me/" in app.pay_popup_html(c, "hum") and "cs-go-unlock-hum" in app.pay_popup_html(c, "hum") | |
| def test_pay_per_use_buttons_and_admin_table_are_wired(): | |
| cfg = app.demo.get_config_file() | |
| ids = {c["props"].get("elem_id"): c["id"] for c in cfg["components"] if c["props"].get("elem_id")} | |
| assert {"cs-go-unlock-smart", "cs-go-unlock-hum"} <= set(ids) | |
| triggers = {t[0] for d in cfg["dependencies"] for t in d["targets"]} | |
| assert ids["cs-go-unlock-smart"] in triggers and ids["cs-go-unlock-hum"] in triggers | |
| labels = {str(c["props"].get("value") or "") for c in cfg["components"]} | |
| assert any("Mark paid" in x for x in labels) and any("yearly" in x.lower() for x in labels) | |
| # ---------------------------------------------------------------- automatic proofread | |
| class _Rep: | |
| meta = {} | |
| def __call__(self, *a, **k): | |
| pass | |
| def _smart_res(path): | |
| blocks = D.classify([D.Block(D._norm(TEXT))], D.PASTE_MIN_WORDS) | |
| D.analyse(blocks, scorer=lambda texts: [0.0] * len(texts)) | |
| stats = lambda p: dict(pct=p, analysed=30, high=0, moderate=0, all_words=30) | |
| return dict(before=stats(90), after=stats(10), log=["Pass 1: AI score 90% → rewrote 2 of 2 flagged sentences"], | |
| note="", blocks=blocks, path=path, report=None, orig="The original text.", new=TEXT) | |
| def test_a_humanized_document_is_proofread_automatically(tmp_path, monkeypatch): | |
| src, hum, proofed = _docx(tmp_path, "in.docx"), _docx(tmp_path, "in_humanized.docx"), \ | |
| _docx(tmp_path, "in_proofread.docx", TEXT.replace("reached", "achieved")) | |
| monkeypatch.setattr(D, "score_texts", lambda texts: [0.0] * len(texts)) | |
| monkeypatch.setattr(S, "smart_docx", lambda *a: _smart_res(hum)) | |
| seen = {} | |
| def proofread(path, orig, rep, hi, mod, protect_ai=False): | |
| seen.update(path=path, orig=orig, protect=protect_ai) | |
| return dict(path=proofed, before=dict(pct=10, all_words=30), after=dict(pct=8, all_words=30, analysed=30, | |
| high=0, moderate=0), n=1, total=2, note="", notes=[], single=True, limited=False) | |
| import proofread as PR | |
| monkeypatch.setattr(PR, "proofread_docx", proofread) | |
| out = app._smart_docx_core(src, 0, 2, 0.9, "Auto", 0.8, 0.5, False, 0, None, None, app.GOALS[0], _Rep()) | |
| assert seen == dict(path=hum, orig=src, protect=True) # the humanized file, with the upload as reference | |
| assert "Proofread:" in out[0] and "done automatically, 1 of 2" in out[0] and "90% → 8%" in out[0] | |
| assert out[3] == proofed # the customer downloads the proofread file | |
| def test_the_humanized_file_is_still_delivered_if_the_proofread_fails(tmp_path, monkeypatch): | |
| src, hum = _docx(tmp_path, "in.docx"), _docx(tmp_path, "in_humanized.docx") | |
| monkeypatch.setattr(D, "score_texts", lambda texts: [0.0] * len(texts)) | |
| monkeypatch.setattr(S, "smart_docx", lambda *a: _smart_res(hum)) | |
| import proofread as PR | |
| def boom(*a, **k): | |
| raise ValueError("layout changed") | |
| monkeypatch.setattr(PR, "proofread_docx", boom) | |
| out = app._smart_docx_core(src, 0, 2, 0.9, "Auto", 0.8, 0.5, False, 0, None, None, app.GOALS[0], _Rep()) | |
| assert out[3] == hum and "could not run this time" in out[0] | |
| def test_the_humanizer_skips_its_own_polish_when_the_proofread_follows(monkeypatch): | |
| called = [] | |
| monkeypatch.setattr(H.G, "available", lambda: True) | |
| monkeypatch.setattr(H.G, "polish", lambda *a, **k: called.append("polish") or []) | |
| monkeypatch.setattr(H.G, "grammar", lambda s, *a, **k: called.append("grammar") or list(s)) | |
| monkeypatch.setattr(H.LT, "MODE", "off") | |
| monkeypatch.setattr(H.FL, "scores", lambda texts: [0.9] * len(texts)) | |
| tok = H.PROOFREAD_FOLLOWS.set(True) | |
| try: | |
| H.grammar_fix_sentences(["A rewritten sentence that is perfectly fine here."], frozenset()) | |
| finally: | |
| H.PROOFREAD_FOLLOWS.reset(tok) | |
| assert called == [] # one final check (the proofread), not two | |
| def test_pricing_page_shows_pay_per_use_and_monthly_or_yearly(): | |
| month = P.pricing_html("INR", "Monthly") | |
| assert "Pay per use" in month and "pay only to download" in month and "done automatically" in month | |
| assert "₹999" in month and "/month" in month and "Yearly: ₹9,590 a year (save 20%)" in month | |
| year = P.pricing_html("INR", P.BILLING[1]) | |
| assert "₹9,590" in year and "/year" in year and "₹28,790" in year | |
| assert "works out at ₹799/month instead of ₹999" in year and "12 months for the price of 9.6" in year | |
| usd = P.pricing_html("USD", P.BILLING[1]) | |
| assert "$134" in usd and "/year" in usd | |
| def test_a_proofread_that_raises_the_ai_score_is_not_used(tmp_path, monkeypatch): | |
| """Live case: humanizing reached 0%, the automatic proofread put the author's wording back and the customer got | |
| 100%. The humanized file is delivered instead, and the message says why.""" | |
| src, hum, proofed = _docx(tmp_path, "in.docx"), _docx(tmp_path, "in_humanized.docx"), _docx(tmp_path, "in_proofread.docx", TEXT.replace("reached", "achieved")) | |
| monkeypatch.setattr(D, "score_texts", lambda texts: [0.0] * len(texts)) | |
| monkeypatch.setattr(S, "smart_docx", lambda *a: _smart_res(hum)) | |
| import proofread as PR | |
| monkeypatch.setattr(PR, "proofread_docx", lambda *a, **k: dict( | |
| path=proofed, before=dict(pct=10, all_words=30), after=dict(pct=100, all_words=30, analysed=30, high=30, | |
| moderate=0), | |
| n=2, total=2, note="", notes=[], single=True, limited=False)) | |
| out = app._smart_docx_core(src, 0, 2, 0.9, "Auto", 0.8, 0.5, False, 0, None, None, app.GOALS[0], _Rep()) | |
| assert out[3] == hum # the humanized file, not the proofread one | |
| assert "would have raised the AI score" in out[0] and "90% → 10%" in out[0] | |
| def test_checking_models_stay_on_the_cpu_without_a_dedicated_gpu(monkeypatch): | |
| import torch | |
| import runtime as RT | |
| m = torch.nn.Linear(2, 2) | |
| monkeypatch.setattr(RT, "HELPERS_GPU", False) | |
| assert RT.to_gpu(m) is m and RT.device_of(m).type == "cpu" | |
| monkeypatch.setattr(RT, "HELPERS_GPU", True) # a GPU that fails: the model still works on CPU | |
| monkeypatch.setattr(m, "to", lambda *a, **k: (_ for _ in ()).throw(RuntimeError("CUDA out of memory"))) | |
| assert RT.to_gpu(m) is m | |
| def test_learned_banned_words_are_suppressed_without_the_slow_bad_words_filter(monkeypatch): | |
| """5,500 bad_words_ids sequences made every Parrot call take 20-30 s on the Space's GPU. Single-token bans now go | |
| through suppress_tokens; longer ones are left to banned_in().""" | |
| import adaptive as AD | |
| class Tok: | |
| ids = {"delve": [7], " delve": [8], "Delve": [9], " Delve": [10], "tapestry": [11, 12]} | |
| def __call__(self, form, add_special_tokens=False): | |
| return type("E", (), {"input_ids": self.ids.get(form, [99, 98])})() | |
| monkeypatch.setattr(AD, "banned", lambda: {"delve", "tapestry"}) | |
| AD._bw_cache.clear() | |
| assert AD.suppress_ids(Tok()) == [7, 8, 9, 10] | |
| monkeypatch.setattr(AD, "banned", lambda: set()) | |
| AD._bw_cache.clear() | |
| assert AD.suppress_ids(Tok()) is None | |