initial code commit

.gitignore

@@ -0,0 +1,3 @@
+.venv
+.mypy_cache
+__pycache__

README.md

@@ -1,8 +1,8 @@
 ---
 title: Argdown Feedback
-emoji: 😻
-colorFrom: red
-colorTo: red
+emoji: 👌
+colorFrom: orange
+colorTo: green
 sdk: gradio
 sdk_version: 5.24.0
 app_file: app.py

app.py

@@ -0,0 +1,28 @@
+import gradio as gr
+
+from backend.examples import get_examples, get_example_labels
+from backend.pipelines import run_verification_pipeline
+
+def verifier(inputs, verifier_id):
+    return run_verification_pipeline(inputs, verifier_id)
+
+demo = gr.Interface(
+    verifier,
+    [
+        gr.Code(lines=8, label="Input text with argdown code block", wrap_lines=True),
+        gr.Dropdown(
+            [("Logical reconstruction", "log_reco"), ("Logical reconstruction and argument map", "log_reco_and_map")],
+            value="log_reco",
+            label="Verification Pipeline"
+        ),
+    ],
+    "markdown",
+    flagging_mode="never",
+    examples=get_examples(),
+    example_labels=get_example_labels(),
+    title="👌 Argdown-Feedback",
+    description="Let this app check your [Argdown](https://argdown.org) code snippets. Please report any bugs or share impressions in the [Community](https://huggingface.co/spaces/DebateLabKIT/argdown-feedback/discussions) section.",
+    theme="base",
+)
+
+demo.launch()

backend/examples.py

@@ -0,0 +1,57 @@
+import textwrap
+
+EXAMPLES = [
+    {
+        "label": "Drew on democratic elections",
+        "inputs": textwrap.dedent("""
+        Elizabeth Drew: "Can We Have a Democratic Election?" (2012)
+
+        A simple, stylized reconstruction:
+
+        ```argdown
+        <Drew's Argument>
+                                  
+        (1) The power of organized moneyed interests in the electoral system (in which the presidential election will take place) is growing. {formalization: "F(a)", declarations: {"a": "the presidential election", "F": "will take place in an electoral system where the power of organized moneyed interests is growing"}}
+        (2) If the power of organized moneyed interests in the electoral system (in which a given election will take place) is growing, then that very election will be subjected to seriously self-interested contortions. {formalization: "all x.(F(x) -> G(x))", declarations: {"G": "will be subjected to seriously self-interested contortions"}}
+        -- {from: ["1","2"]} --
+        (3) The presidential election will be subjected to seriously self-interested contortions. {formalization: "G(a)"}
+        ```
+        """),
+        "verifier_id": "log_reco",       
+    },
+    {
+        "label": "Krugman on planet to exploit",
+        "inputs": textwrap.dedent("""                                
+        An argument from Paul Krugman's NYT column: "Running Out of Planet to Exploit" (April 28 2008)
+
+        ```argdown
+        <Krugman's Argument>
+
+        (1) Either supply for oil (and natural resources) will increase in the near term or the era of cheap resources is over for good. {formalization: "p or q", declarations: {"p": "supply will increase in the near term", "q": "the era of cheap resources is over for good"}}
+        (2) Supply for oil (and natural resources) will not increase in the near term. {formalization: "-p"}
+        -- {from: ["1","2"]} --
+        (3) The era of cheap resources is over for good. {formalization: "q"}
+        (4) Cheap natural resources are required for raising living standards. {formalization: "r", declarations: {"r": "cheap natural resources are required for raising living standards"}}
+        (5) If cheap resources are required for raising living standards, but there will be no cheap resources in the future, then it will be harder for all countries to further raise their standard of living. {formalization: "r -> s", declarations: {"s": "it will be harder for all countries to further raise their standard of living"}} // FLAWED FORMALIZATION here renders first sub-argument irrelevant, change this to "(q & r) -> s"
+        -- {from: ["3","4","5"]} --
+        (6) It will be harder for all countries to further raise their standard of living. {formalization: "s"}
+        (7) If it becomes harder, for all countries, to further raise their standard of living, then some poor countries face the serious risk of collapse into anarchy. {formalization: "s -> t", declarations: {"t": "some poor countries face the serious risk of collapse into anarchy"}}
+        -- {from: ["6","7"]} --
+        (8) It will be harder for rich countries to further raise their standard of living, and some poor countries face the serious risk of collapse into anarchy. {formalization: "s and t"}
+        ```
+        """),
+        "verifier_id": "log_reco",
+    },
+]
+
+def get_examples():
+    return [
+        [example["inputs"], example["verifier_id"]]
+        for example in EXAMPLES
+    ]
+
+def get_example_labels():
+    return [
+        example["label"]
+        for example in EXAMPLES
+    ]

backend/pipelines.py

@@ -0,0 +1,54 @@
+import pprint
+
+from argdown_feedback.tasks.base import Evaluation
+from argdown_feedback.verifiers.base import CompositeHandler
+from argdown_feedback.verifiers.core.infreco_handler import InfRecoCompositeHandler, NoPropInlineDataHandler, HasGistHandler
+from argdown_feedback.verifiers.core.logreco_handler import LogRecoCompositeHandler
+from argdown_feedback.verifiers.core.content_check_handler import HasArgdownHandler
+from argdown_feedback.verifiers.processing_handler import DefaultProcessingHandler
+from argdown_feedback.verifiers.verification_request import VerificationRequest
+
+
+def run_verification_pipeline(inputs, verifier_id):
+    if verifier_id == "log_reco":
+        return run_log_reco(inputs)
+
+    return "Not implemented"
+
+def run_log_reco(inputs):
+    if not inputs:
+        return "No input provided"    
+
+    infreco_handler = InfRecoCompositeHandler()
+    infreco_handler.handlers = [
+        h for h in infreco_handler.handlers
+        if not isinstance(h, NoPropInlineDataHandler) and not isinstance(h, HasGistHandler)
+    ]
+
+    handler = CompositeHandler(
+        handlers=[
+            DefaultProcessingHandler(),
+            HasArgdownHandler(),
+            infreco_handler,
+            LogRecoCompositeHandler(),
+        ]
+    )
+    request = VerificationRequest(inputs=inputs)
+    result = handler.process(request)
+    evaluation = Evaluation.from_verification_request(result)
+    
+
+
+    report_lines = []
+    report_lines.append("## Verification Results\n")
+    if evaluation.is_valid:
+        report_lines.append("✅ All clear. No issues detected in the input.")
+    else:
+        report_lines.append("❌ The input is flawed.")
+
+        report_lines.append("\n### Issues\n")
+        for k,v in evaluation.metrics.items():
+            if v is not None:
+                report_lines.append(f"‼️ {v}\n")
+
+    return "\n".join(report_lines)

requirements.txt

@@ -0,0 +1,3 @@
+git+https://github.com/debatelab/argdown-feedback.git
+gradio
+pandas