begun basic implementation of parser for content validation suing the parsely API with scala

Author: HarrySu123

.gitignore

@@ -701,3 +701,9 @@ media_ans/
 dist-newstyle/
 dist/
 .stack-work/
+
+
+# Scala build artifacts
+.bsp/
+.scala-build/
+.metals/

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "files.watcherExclude": {
+        "**/target": true
+    }
+}

conversion2025/mathpix_to_llm_to_in2lambda_to_JSON.ipynb

@@ -974,7 +974,7 @@
     "    print(json.dumps(extracted_dict, indent=2))\n",
     "    print(\"Now validating the content...\")\n",
     "\n",
-    "    # return extracted_dict\n",
+    "    return extracted_dict\n",
     "\n",
     "    content_validated_dict = content_texdown_check(extracted_dict)\n",
     "    print(\"successfully validated the content.\")\n",

conversion2025/testing.ipynb

@@ -72,6 +72,24 @@
     "output = pypandoc.convert_text('# Hello', 'html', format='md')\n",
     "print(output)"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import requests\n",
+    "\n",
+    "data = \"x^2 + y^2 = z^2\"\n",
+    "resp = requests.post(\"http://localhost:8080/process\", data=data)\n",
+    "\n",
+    "if resp.ok:\n",
+    "    print(\"✅ Processed:\", resp.text)\n",
+    "else:\n",
+    "    print(\"❌ Error:\", resp.status_code)"
+   ]
   }
  ],
  "metadata": {

conversion2025/tools/validator/app/Main.hs

@@ -0,0 +1,14 @@
+name := "validator"
+
+version := "0.1"
+
+scalaVersion := "3.3.1"
+
+libraryDependencies ++= Seq(
+  "org.typelevel" %% "cats-effect" % "3.5.1",
+  "org.http4s" %% "http4s-dsl" % "1.0.0-M39",
+  "org.http4s" %% "http4s-ember-server" % "1.0.0-M39",
+  "ch.qos.logback" % "logback-classic" % "1.4.11",
+  "com.github.j-mie6" %% "parsley" % "5.0.0-M9",
+  "org.scalameta" %% "munit" % "1.0.0-M11" % Test
+)

conversion2025/tools/validator/build.sbt

@@ -0,0 +1 @@
+sbt.version=1.11.3

conversion2025/tools/validator/project/build.properties

@@ -0,0 +1,32 @@
+import cats.effect._
+import org.http4s._
+import org.http4s.dsl.io._
+import org.http4s.ember.server.EmberServerBuilder
+import org.http4s.server.Router
+import com.comcast.ip4s.{Host, Port}
+
+object Main extends IOApp {
+
+  val mathRoutes = HttpRoutes.of[IO] {
+    case req @ POST -> Root / "process" =>
+      req.as[String].flatMap { input =>
+        val cleaned = input.trim.reverse // Example logic
+        Ok(s"Processed: $cleaned")
+      }
+  }
+
+  val httpApp = Router("/" -> mathRoutes).orNotFound
+
+  val host: Host = Host.fromString("localhost").getOrElse(Host.fromString("0.0.0.0").get)
+  val port: Port = Port.fromInt(8080).getOrElse(Port.fromInt(80).get)
+
+  def run(args: List[String]): IO[ExitCode] =
+    EmberServerBuilder
+      .default[IO]
+      .withHost(host)
+      .withPort(port)
+      .withHttpApp(httpApp)
+      .build
+      .use(_ => IO.never)
+      .as(ExitCode.Success)
+}

conversion2025/tools/validator/src/main/scala/Main.scala

@@ -0,0 +1,29 @@
+import parsley.Parsley
+import parsley.token.{Lexer, Basic}
+import parsley.token.descriptions.*
+import parsley.errors.combinator.*
+
+
+object lexer {
+    private val genericKeywords = Set(
+        "$$", "$"
+    )
+
+    private val desc = LexicalDesc.plain.copy(
+        nameDesc = NameDesc.plain.copy(
+            identifierStart = Basic(_.isInstanceOf[Char]),
+            identifierLetter = Basic(_.isInstanceOf[Char]),
+        ),
+        symbolDesc = SymbolDesc.plain.copy(
+            hardOperators = genericKeywords,
+        )
+    )
+
+    private val lexer = Lexer(desc)
+
+    def fully[A](p: Parsley[A]): Parsley[A] = lexer.fully(p)
+
+    val text: Parsley[String] = lexer.lexeme.names.identifier
+    
+    val implicits = lexer.lexeme.symbol.implicits
+}

conversion2025/tools/validator/src/main/scala/lexer.scala

@@ -0,0 +1,30 @@
+import parsley.quick.*
+import parsley.syntax.zipped.*
+import parsley.expr.chain
+import parsley.expr.{precedence, Ops, InfixL}
+import parsley.errors.ErrorBuilder
+import parsley.errors.combinator.*
+
+import lexer.{fully, text}
+import lexer.implicits.implicitSymbol
+
+import Block.*
+
+
+object parser {
+  def parse[Err: ErrorBuilder](input: String): Either[Err, MarkDown] = parser.parse(input).toEither
+
+  private lazy val parser = fully(markDown)
+
+  private lazy val markDown = MarkDown(blocks)
+
+  private lazy val blocks = many(block)
+
+  private lazy val block: Parsley[Block] = 
+    Display(display) |
+    Inline(inline) |
+    Text(lexer.text)
+
+  private lazy val display = "$$" ~> lexer.text <~ "$$"
+  private lazy val inline = "$" ~> lexer.text <~ "$"
+}