Upload folder using huggingface_hub

Code_Conversion_Dataset.ipynb

@@ -0,0 +1,43 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import pandas as pd\n",
+    "\n",
+    "def get_code_pairs(directory):\n",
+    "    pairs = []\n",
+    "    for filename in os.listdir(os.path.join(directory, \"python\")):\n",
+    "        if filename.endswith(\".py\"):\n",
+    "            rust_filename = filename.replace(\".py\", \".rs\")\n",
+    "            python_path = os.path.join(directory, \"python\", filename)\n",
+    "            rust_path = os.path.join(directory, \"rust\", rust_filename)\n",
+    "            if os.path.exists(rust_path):\n",
+    "                with open(python_path, \"r\") as f:\n",
+    "                    python_code = f.read()\n",
+    "                with open(rust_path, \"r\") as f:\n",
+    "                    rust_code = f.read()\n",
+    "                pairs.append((python_code, rust_code))\n",
+    "    return pairs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pairs = get_code_pairs(\".\")\n",
+    "df = pd.DataFrame(pairs, columns=[\"Python\", \"Rust\"])\n",
+    "df"
+   ]
+  }
+ ],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

python/api_request.py

@@ -0,0 +1,7 @@
+# This script requires the 'requests' library to be installed.
+# You can install it with: pip install requests
+
+import requests
+
+response = requests.get('https://jsonplaceholder.typicode.com/todos/1')
+print(response.json())

python/binary_search_tree.py

@@ -0,0 +1,32 @@
+class Node:
+    def __init__(self, key):
+        self.left = None
+        self.right = None
+        self.val = key
+
+def insert(root, key):
+    if root is None:
+        return Node(key)
+    else:
+        if root.val < key:
+            root.right = insert(root.right, key)
+        else:
+            root.left = insert(root.left, key)
+    return root
+
+def inorder(root):
+    if root:
+        inorder(root.left)
+        print(root.val)
+        inorder(root.right)
+
+
+r = Node(50)
+r = insert(r, 30)
+r = insert(r, 20)
+r = insert(r, 40)
+r = insert(r, 70)
+r = insert(r, 60)
+r = insert(r, 80)
+
+inorder(r)

python/closures.py

@@ -0,0 +1,7 @@
+def outer_func(x):
+    def inner_func(y):
+        return x + y
+    return inner_func
+
+add_5 = outer_func(5)
+print(add_5(10))

python/concurrency.py

@@ -0,0 +1,13 @@
+import threading
+import time
+
+def worker():
+    print("Worker thread starting...")
+    time.sleep(1)
+    print("Worker thread finishing.")
+
+thread = threading.Thread(target=worker)
+thread.start()
+thread.join()
+
+print("Main thread finishing.")

python/error_handling.py

@@ -0,0 +1,9 @@
+def divide(a, b):
+    try:
+        result = a / b
+        print(f"Result: {result}")
+    except ZeroDivisionError:
+        print("Error: Cannot divide by zero.")
+
+divide(10, 2)
+divide(10, 0)

python/factorial.py

@@ -0,0 +1,7 @@
+def factorial(n):
+    if n == 0:
+        return 1
+    else:
+        return n * factorial(n-1)
+
+print(factorial(5))

python/hello_world.py

@@ -0,0 +1 @@
+print("Hello, World!")

python/iterators.py

@@ -0,0 +1,17 @@
+class Fibonacci:
+    def __init__(self, limit):
+        self.limit = limit
+        self.a, self.b = 0, 1
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self.a > self.limit:
+            raise StopIteration
+        val = self.a
+        self.a, self.b = self.b, self.a + self.b
+        return val
+
+for i in Fibonacci(100):
+    print(i)

python/palindrome.py

@@ -0,0 +1,5 @@
+def is_palindrome(s):
+    return s == s[::-1]
+
+print(is_palindrome("racecar"))
+print(is_palindrome("hello"))

python/pattern_matching.py

@@ -0,0 +1,14 @@
+def describe(x):
+    if x == 1:
+        print("one")
+    elif x == 2:
+        print("two")
+    elif isinstance(x, str):
+        print("a string")
+    else:
+        print("something else")
+
+describe(1)
+describe(2)
+describe("hello")
+describe([1, 2, 3])

python/person.py

@@ -0,0 +1,10 @@
+class Person:
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+
+    def greet(self):
+        print(f"Hello, my name is {self.name} and I am {self.age} years old.")
+
+person = Person("Alice", 30)
+person.greet()

python/quicksort.py

@@ -0,0 +1,10 @@
+def quicksort(arr):
+    if len(arr) <= 1:
+        return arr
+    pivot = arr[len(arr) // 2]
+    left = [x for x in arr if x < pivot]
+    middle = [x for x in arr if x == pivot]
+    right = [x for x in arr if x > pivot]
+    return quicksort(left) + middle + quicksort(right)
+
+print(quicksort([3, 6, 8, 10, 1, 2, 1]))

python/web_server.py

@@ -0,0 +1,17 @@
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+class SimpleServer(BaseHTTPRequestHandler):
+    def do_GET(self):
+        self.send_response(200)
+        self.send_header('Content-type', 'text/html')
+        self.end_headers()
+        self.wfile.write(b'<html><body><h1>Hello, World!</h1></body></html>')
+
+def run(server_class=HTTPServer, handler_class=SimpleServer, port=8000):
+    server_address = ('', port)
+    httpd = server_class(server_address, handler_class)
+    print(f'Starting httpd on port {port}...')
+    httpd.serve_forever()
+
+if __name__ == "__main__":
+    run()

python/word_frequency.py

@@ -0,0 +1,8 @@
+from collections import Counter
+
+def word_frequency(file_path):
+    with open(file_path, 'r') as f:
+        words = f.read().split()
+    return Counter(words)
+
+print(word_frequency('sample.txt'))

rust/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "rust_web_server"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+hyper = { version = "0.14", features = ["full"] }
+tokio = { version = "1", features = ["full"] }
+reqwest = { version = "0.11", features = ["json"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"

rust/factorial.rs

@@ -0,0 +1,11 @@
+fn factorial(n: u64) -> u64 {
+    if n == 0 {
+        1
+    } else {
+        n * factorial(n - 1)
+    }
+}
+
+fn main() {
+    println!("{}", factorial(5));
+}

rust/hello_world.rs

@@ -0,0 +1,3 @@
+fn main() {
+    println!("Hello, World!");
+}

rust/palindrome.rs

@@ -0,0 +1,8 @@
+fn is_palindrome(s: &str) -> bool {
+    s.chars().eq(s.chars().rev())
+}
+
+fn main() {
+    println!("{}", is_palindrome("racecar"));
+    println!("{}", is_palindrome("hello"));
+}

rust/person.rs

@@ -0,0 +1,19 @@
+struct Person {
+    name: String,
+    age: u32,
+}
+
+impl Person {
+    fn new(name: String, age: u32) -> Person {
+        Person { name, age }
+    }
+
+    fn greet(&self) {
+        println!("Hello, my name is {} and I am {} years old.", self.name, self.age);
+    }
+}
+
+fn main() {
+    let person = Person::new("Alice".to_string(), 30);
+    person.greet();
+}

rust/src/api_request.rs

@@ -0,0 +1,23 @@
+use serde::Deserialize;
+use reqwest;
+
+#[derive(Deserialize, Debug)]
+struct Todo {
+    #[serde(rename = "userId")]
+    user_id: i32,
+    id: i32,
+    title: String,
+    completed: bool,
+}
+
+#[tokio::main]
+async fn main() -> Result<(), reqwest::Error> {
+    let todo: Todo = reqwest::get("https://jsonplaceholder.typicode.com/todos/1")
+        .await?
+        .json()
+        .await?;
+
+    println!("{:?}", todo);
+
+    Ok(())
+}

rust/src/binary_search_tree.rs

@@ -0,0 +1,49 @@
+#![allow(dead_code)]
+
+#[derive(Debug)]
+struct Node {
+    val: i32,
+    left: Option<Box<Node>>,
+    right: Option<Box<Node>>,
+}
+
+impl Node {
+    fn new(val: i32) -> Self {
+        Node { val, left: None, right: None }
+    }
+}
+
+fn insert(root: Option<Box<Node>>, val: i32) -> Option<Box<Node>> {
+    match root {
+        None => Some(Box::new(Node::new(val))),
+        Some(mut node) => {
+            if val < node.val {
+                node.left = insert(node.left, val);
+            } else {
+                node.right = insert(node.right, val);
+            }
+            Some(node)
+        }
+    }
+}
+
+fn inorder(root: &Option<Box<Node>>) {
+    if let Some(node) = root {
+        inorder(&node.left);
+        println!("{}", node.val);
+        inorder(&node.right);
+    }
+}
+
+fn main() {
+    let mut root = None;
+    root = insert(root, 50);
+    root = insert(root, 30);
+    root = insert(root, 20);
+    root = insert(root, 40);
+    root = insert(root, 70);
+    root = insert(root, 60);
+    root = insert(root, 80);
+
+    inorder(&root);
+}

rust/src/closures.rs

@@ -0,0 +1,7 @@
+fn main() {
+    let outer_var = 5;
+    let closure = |inner_var| {
+        outer_var + inner_var
+    };
+    println!("{}", closure(10));
+}

rust/src/concurrency.rs

@@ -0,0 +1,14 @@
+use std::thread;
+use std::time::Duration;
+
+fn main() {
+    let handle = thread::spawn(|| {
+        println!("Worker thread starting...");
+        thread::sleep(Duration::from_secs(1));
+        println!("Worker thread finishing.");
+    });
+
+    handle.join().unwrap();
+
+    println!("Main thread finishing.");
+}

rust/src/error_handling.rs

@@ -0,0 +1,19 @@
+fn divide(a: f64, b: f64) -> Result<f64, String> {
+    if b == 0.0 {
+        Err("Cannot divide by zero".to_string())
+    } else {
+        Ok(a / b)
+    }
+}
+
+fn main() {
+    match divide(10.0, 2.0) {
+        Ok(result) => println!("Result: {}", result),
+        Err(e) => println!("Error: {}", e),
+    }
+
+    match divide(10.0, 0.0) {
+        Ok(result) => println!("Result: {}", result),
+        Err(e) => println!("Error: {}", e),
+    }
+}

rust/src/iterators.rs

@@ -0,0 +1,31 @@
+struct Fibonacci {
+    limit: u32,
+    a: u32,
+    b: u32,
+}
+
+impl Fibonacci {
+    fn new(limit: u32) -> Self {
+        Fibonacci { limit, a: 0, b: 1 }
+    }
+}
+
+impl Iterator for Fibonacci {
+    type Item = u32;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.a > self.limit {
+            return None;
+        }
+        let val = self.a;
+        self.a = self.b;
+        self.b = val + self.b;
+        Some(val)
+    }
+}
+
+fn main() {
+    for i in Fibonacci::new(100) {
+        println!("{}", i);
+    }
+}

rust/src/main.rs

@@ -0,0 +1,25 @@
+use hyper::service::{make_service_fn, service_fn};
+use hyper::{Body, Request, Response, Server};
+use std::convert::Infallible;
+use std::net::SocketAddr;
+
+async fn handle(_: Request<Body>) -> Result<Response<Body>, Infallible> {
+    Ok(Response::new("<h1>Hello, World!</h1>".into()))
+}
+
+#[tokio::main]
+async fn main() {
+    let addr = SocketAddr::from(([127, 0, 0, 1], 8000));
+
+    let make_svc = make_service_fn(|_conn| async {
+        Ok::<_, Infallible>(service_fn(handle))
+    });
+
+    let server = Server::bind(&addr).serve(make_svc);
+
+    println!("Listening on http://{}", addr);
+
+    if let Err(e) = server.await {
+        eprintln!("server error: {}", e);
+    }
+}

rust/src/pattern_matching.rs

@@ -0,0 +1,26 @@
+fn describe(x: &dyn std::any::Any) {
+    match x {
+        x if x.is::<i32>() => {
+            if let Some(val) = x.downcast_ref::<i32>() {
+                match val {
+                    1 => println!("one"),
+                    2 => println!("two"),
+                    _ => println!("an integer"),
+                }
+            }
+        }
+        x if x.is::<&str>() => {
+            println!("a string");
+        }
+        _ => {
+            println!("something else");
+        }
+    }
+}
+
+fn main() {
+    describe(&1);
+    describe(&2);
+    describe(&"hello");
+    describe(&vec![1, 2, 3]);
+}

rust/src/quicksort.rs

@@ -0,0 +1,29 @@
+fn quicksort<T: Ord>(arr: &mut [T]) {
+    if arr.len() <= 1 {
+        return;
+    }
+    let pivot = arr.len() / 2;
+    let (left, right) = arr.split_at_mut(pivot);
+    quicksort(left);
+    quicksort(&mut right[1..]);
+    let mut temp = Vec::with_capacity(arr.len());
+    let (mut i, mut j) = (0, 1);
+    while i < left.len() && j < right.len() {
+        if left[i] < right[j] {
+            temp.push(left[i].clone());
+            i += 1;
+        } else {
+            temp.push(right[j].clone());
+            j += 1;
+        }
+    }
+    temp.extend_from_slice(&left[i..]);
+    temp.extend_from_slice(&right[j..]);
+    arr.clone_from_slice(&temp);
+}
+
+fn main() {
+    let mut arr = vec![3, 6, 8, 10, 1, 2, 1];
+    quicksort(&mut arr);
+    println!("{:?}", arr);
+}

rust/word_frequency.rs

@@ -0,0 +1,16 @@
+use std::collections::HashMap;
+use std::fs;
+
+fn word_frequency(file_path: &str) -> HashMap<String, u32> {
+    let contents = fs::read_to_string(file_path).expect("Something went wrong reading the file");
+    let mut map = HashMap::new();
+    for word in contents.split_whitespace() {
+        let count = map.entry(word.to_string()).or_insert(0);
+        *count += 1;
+    }
+    map
+}
+
+fn main() {
+    println!("{:?}", word_frequency("sample.txt"));
+}

sample.txt

@@ -0,0 +1 @@
+hello world this is a test hello world