feat(clex_llm): expose default codegen language type

feat(cpast): --problem_url args in ai and test routes

feat(cscrapper): new ProgramStore api new_from_language

chore(cpast_api): updated schema to store language name in cache and use language from clex_llm instead of c++ as default

Author: rootCircle

.sqlx/query-63bdeb19e8cace053771d10515dd93eb7f583e7612cabd52d634335606a8cfde.json

@@ -19,7 +19,7 @@ rust-version.workspace = true
 which = { workspace = true }
 serde = { features = ["derive"], workspace = true }
 utoipa = { workspace = true }
-tokio.workspace = true
+tokio = { workspace = true }
 tempfile = { workspace = true }
 rand = { workspace = true }
 regex = { workspace = true }

.sqlx/query-379c67534427b83f2db00aa7a3b7d0d0ddd349a3d426d3c471e7be8bd26d8a21.json renamed to .sqlx/query-c4fad0683162d8a33694a72082fddafda347ba88a493421f0130d2c765c42a6c.json

@@ -11,5 +11,5 @@
 pub(crate) mod file_store;
 pub mod language_name;
 pub mod program_store;
-pub(crate) mod runner;
+pub mod runner;
 pub mod runner_error_types;

.sqlx/query-cf3e1d7044a8765a858edb41da4208a269d7a3cfa606783c5eed6579e3ebe589.json

@@ -68,6 +68,16 @@ impl ProgramStore {
         })
     }
 
+    pub fn new_from_language(
+        correct_lang: Language,
+        test_lang: Language,
+    ) -> Result<Self, Box<RunnerErrorType>> {
+        Ok(ProgramStore {
+            correct_file: correct_lang,
+            test_file: test_lang,
+        })
+    }
+
     /// Run both correct and test files with the given input and compare their outputs
     ///
     /// # Arguments

Cargo.lock

@@ -7,17 +7,14 @@ use super::language_name::{CompilationType, LanguageName};
 use super::runner_error_types::RunnerErrorType;
 
 #[derive(Debug)]
-pub(crate) struct Language {
+pub struct Language {
     pub(crate) code: SourceCodeInfo,
     is_compiled: bool, // For program optimization
     do_force_compile: bool,
 }
 
 impl Language {
-    pub(crate) fn new(
-        file_path: &Path,
-        do_force_compile: bool,
-    ) -> Result<Self, Box<RunnerErrorType>> {
+    pub fn new(file_path: &Path, do_force_compile: bool) -> Result<Self, Box<RunnerErrorType>> {
         let code = SourceCodeInfo::new(file_path)?;
 
         let mut lang = Self {
@@ -34,7 +31,7 @@ impl Language {
         Ok(lang)
     }
 
-    pub(crate) fn new_from_custom_dest(
+    pub fn new_from_custom_dest(
         file_path: &Path,
         dest_path: Option<&Path>,
         do_force_compile: bool,
@@ -55,7 +52,7 @@ impl Language {
         Ok(lang)
     }
 
-    pub(crate) fn new_from_text(
+    pub fn new_from_text(
         source_text: &str,
         lang: LanguageName,
         do_force_compile: bool,

ccode_runner/Cargo.toml

@@ -15,6 +15,4 @@ rust-version.workspace = true
 serde = { workspace = true, features = ["derive"] }
 google-generative-ai-rs = { workspace = true, features = ["beta"] }
 tokio = { workspace = true, features = ["full"] }
-
-[dev-dependencies]
 ccode_runner = { path = "../ccode_runner", version = "0.3.2"}

ccode_runner/src/lang_runner.rs

@@ -1,3 +1,4 @@
+use ccode_runner::lang_runner::language_name::LanguageName;
 use google_generative_ai_rs::v1::{
     api::{Client, PostResult},
     errors::GoogleAPIError,
@@ -12,6 +13,7 @@ use super::examples::{self, SolutionTurn};
 pub struct CodeSolutionGenerator {
     examples: Vec<SolutionTurn>,
     client: Client,
+    language: LanguageName,
 }
 
 impl CodeSolutionGenerator {
@@ -20,7 +22,15 @@ impl CodeSolutionGenerator {
 
         let client = Client::new_from_model(Model::Gemini2_0Flash, api_key.to_string());
 
-        Ok(CodeSolutionGenerator { examples, client })
+        Ok(CodeSolutionGenerator {
+            examples,
+            client,
+            language: LanguageName::Cpp,
+        })
+    }
+
+    pub(crate) fn get_language(&self) -> &LanguageName {
+        &self.language
     }
 
     fn get_system_prompt(&self) -> &str {

ccode_runner/src/lang_runner/program_store.rs

@@ -31,6 +31,7 @@
 //!
 //! # Prerequisites
 //! - A valid Google Generative AI API key (get the API key from <https://makersuite.google.com/app/apikey>)
+use ccode_runner::lang_runner::language_name::LanguageName;
 use clex_generator::runner::ClexPromptGenerator;
 use code_generator::runner::CodeSolutionGenerator;
 use google_generative_ai_rs::v1::errors::GoogleAPIError;
@@ -100,8 +101,11 @@ pub async fn generate_code_solution(
     statement: &str,
     input_format: &str,
     constraints: &str,
-) -> Result<String, GoogleAPIError> {
-    generator
-        .generate_response(statement, input_format, constraints)
-        .await
+) -> Result<(String, LanguageName), GoogleAPIError> {
+    Ok((
+        generator
+            .generate_response(statement, input_format, constraints)
+            .await?,
+        generator.get_language().clone(),
+    ))
 }

ccode_runner/src/lang_runner/runner.rs

@@ -20,14 +20,14 @@ async fn test_generate_code_solution() {
     let result = generate_code_solution(&generator, statement, input_format, constraints).await;
 
     match result {
-        Ok(solution) => {
+        Ok((solution, language_name)) => {
             let correct_code = r#"n = int(input())
 arr = list(map(int, input().split()))
 print(sum(arr))"#;
             let runner = ProgramStore::new_from_text(
                 correct_code,
                 &solution,
-                LanguageName::Python,
+                language_name,
                 LanguageName::Python,
                 false,
             )

clex_llm/Cargo.toml

@@ -23,6 +23,7 @@ clap_complete = { workspace = true }
 clex_gen = { version = "^0.3.2", path = "../clex_gen" }
 ccode_runner = { version = "^0.3.2", path = "../ccode_runner" }
 clex_llm = { version = "^0.2.2", path = "../clex_llm" }
+cscrapper = { path = "../cscrapper" }
 thiserror = { workspace = true }
 
 [dev-dependencies]

clex_llm/src/code_generator/runner.rs

@@ -1,14 +1,14 @@
 use std::env;
 
-use cpast::compile_and_test;
+use cpast::{CodeOrPath, compile_and_test};
 
 #[tokio::main(flavor = "multi_thread", worker_threads = 64)]
 async fn main() {
     let manifest_dir = env!("CARGO_MANIFEST_DIR");
 
     compile_and_test(
         format!("{manifest_dir}/examples/res/correct_approach.cpp"),
-        format!("{manifest_dir}/examples/res/my_approach.cpp"),
+        CodeOrPath::Path(format!("{manifest_dir}/examples/res/my_approach.cpp")),
         "(N[1,5]) (?:(N[1,5]) (?:N[1,100]){\\2}){\\1}".to_owned(),
         100,
         true,

clex_llm/src/lib.rs

@@ -1,14 +1,14 @@
 use std::env;
 
-use cpast::compile_and_test;
+use cpast::{CodeOrPath, compile_and_test};
 
 #[tokio::main(flavor = "multi_thread", worker_threads = 64)]
 async fn main() {
     let manifest_dir = env!("CARGO_MANIFEST_DIR");
 
     compile_and_test(
         format!("{manifest_dir}/examples/res/hello.py"),
-        format!("{manifest_dir}/examples/res/hello.java"),
+        CodeOrPath::Path(format!("{manifest_dir}/examples/res/hello.java")),
         "N".to_owned(),
         100,
         true,

clex_llm/tests/test_code_generator.rs

@@ -47,13 +47,17 @@ pub(crate) struct TestArgs {
     pub(crate) correct_file: Option<String>,
 
     /// The test file
-    #[arg(short, long, required = true, value_hint = ValueHint::FilePath)]
+    #[arg(short, long,  value_hint = ValueHint::FilePath)]
     pub(crate) test_file: Option<String>,
 
     /// Clex for generating Tests
-    #[arg(short, long, required = true, value_hint = ValueHint::Other)]
+    #[arg(short, long,  value_hint = ValueHint::Other)]
     pub(crate) generator: Option<String>,
 
+    /// Coding Problem URL
+    #[arg(short='u', long, value_hint = ValueHint::Url)]
+    pub(crate) problem_url: Option<String>,
+
     /// Max number of times of iterations
     #[arg(short, long, default_value_t = DEFAULT_ITERATIONS_COUNT, value_hint = ValueHint::Other)]
     pub(crate) iterations: usize,
@@ -84,13 +88,17 @@ pub(crate) struct GenerateArgs {
 #[derive(clap::Args)]
 pub(crate) struct AiArgs {
     /// Input format
-    #[arg(short, long, required = true, value_hint = ValueHint::Other)]
+    #[arg(short, long, value_hint = ValueHint::Other)]
     pub(crate) input_format: Option<String>,
 
     /// Constraints
-    #[arg(short, long, required = true, value_hint = ValueHint::Other)]
+    #[arg(short, long, value_hint = ValueHint::Other)]
     pub(crate) constraints: Option<String>,
 
+    /// Problem URL
+    #[arg(short='u', long, value_hint = ValueHint::Url)]
+    pub(crate) problem_url: Option<String>,
+
     /// Copy clex to clipboard
     #[arg(long)]
     pub(crate) clipboard: bool,

cpast/Cargo.toml

@@ -5,30 +5,55 @@
 use cli_clipboard::{ClipboardContext, ClipboardProvider};
 
 use colored::Colorize;
+use cscrapper::qscrapper::ScraperError;
 
 use crate::{cli::cli_parser::AiArgs, error_types::cli_error::CliErrorType};
 
 pub(crate) async fn generate_clex_from_input_format_and_constraints(
     args: AiArgs,
 ) -> Result<(), Box<CliErrorType>> {
+    if !((args.problem_url.is_some() && args.input_format.is_none() && args.constraints.is_none())
+        || (args.problem_url.is_none()
+            && args.input_format.is_some()
+            && args.constraints.is_some()))
+    {
+        return Err(Box::new(CliErrorType::AiRequiredArgsMissing));
+    }
+
     let api_key = std::env::var("GOOGLE_API_KEY").ok();
 
     match api_key {
         Some(api_key) => {
             let generator = clex_llm::create_clex_generator(&api_key)
                 .map_err(|err| Box::new(CliErrorType::ClexLLMInitilizationError(err)))?;
 
-            let input_format = match args.input_format {
-                Some(input_format) => input_format,
-                None => {
-                    return Err(Box::new(CliErrorType::InputFormatMissing));
-                }
-            };
+            let (input_format, constraints) = match args.problem_url {
+                Some(problem_url) => {
+                    let parsed_url = cscrapper::parse_problem_url(&problem_url).ok_or(Box::new(
+                        CliErrorType::CScrapperError(ScraperError::ProblemNotFound),
+                    ))?;
+                    let response = cscrapper::get_problem_statement(parsed_url)
+                        .await
+                        .map_err(|err| Box::new(CliErrorType::CScrapperError(err)))?;
 
-            let constraints = match args.constraints {
-                Some(constraints) => constraints,
+                    (response.input_format, response.constraints)
+                }
                 None => {
-                    return Err(Box::new(CliErrorType::ConstraintsMissing));
+                    let input_format = match args.input_format {
+                        Some(input_format) => input_format,
+                        None => {
+                            return Err(Box::new(CliErrorType::InputFormatMissing));
+                        }
+                    };
+
+                    let constraints = match args.constraints {
+                        Some(constraints) => constraints,
+                        None => {
+                            return Err(Box::new(CliErrorType::ConstraintsMissing));
+                        }
+                    };
+
+                    (input_format, constraints)
                 }
             };