Initial Commit

Author: mvrpl

Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "python-rust-library"
+version = "0.1.0"
+authors = ["marcos"]
+
+[lib]
+name = "mvrpl"
+crate-type = ["dylib"]
+
+[dependencies]
+curl = "0.2.11"
+serde = "1.0"
+serde_derive = "1.0"
+serde_json = "1.0"
+
+[dependencies.cpython]
+git = "https://github.com/dgrunwald/rust-cpython.git"
+default-features = false
+features = ["python27-sys"]

Makefile

@@ -0,0 +1,12 @@
+all: run
+
+build:
+	cargo build --release
+	mv ./target/release/libmvrpl.dylib ./mvrpl.so
+
+run: build
+	python test.py
+
+clean:
+	cargo clean
+	rm ./example.so

src/lib.rs

@@ -0,0 +1,77 @@
+#[macro_use] extern crate cpython;
+extern crate curl;
+extern crate serde;
+extern crate serde_json;
+pub mod utils;
+
+use cpython::{Python, PyDict, PyList, PyResult, ToPyObject, PyObject};
+use curl::http;
+use std::collections::BTreeMap;
+use serde_json::Value;
+
+fn retpy(py: Python) -> PyResult<String> {
+    let locals = PyDict::new(py);
+    locals.set_item(py, "os", py.import("os")?)?;
+    let user: String = py.eval("os.getenv('HOME')", None, Some(&locals))?.extract(py)?;
+    Ok(user.to_string()) 
+}
+
+fn returl(py: Python) -> PyResult<PyObject> {
+    let url = "http://validate.jsontest.com/?json=%7B%22key%22:%22value%22%7D";
+    let resp = http::handle()
+     .get(url)
+     .exec()
+     .unwrap_or_else(|e| {
+         panic!("Falha ao abrir URL {}; Erro: {}", url, e);
+    });
+    let body = std::str::from_utf8(resp.get_body()).unwrap_or_else(|e| {
+        panic!("Falha ao interpretar resultado da URL {}; Erro: {}", url, e);
+    });
+
+    let test: Value = serde_json::from_str(&body).unwrap();
+
+    let ret = utils::fromjson(py, test);
+
+    Ok(ret)
+}
+
+fn retmapa(py: Python) -> PyResult<PyDict> {
+    let dicionario = PyDict::new(py);
+    dicionario.set_item(py, "chave1", "valor1")?;
+    dicionario.set_item(py, "chave2", 123)?;
+    Ok(dicionario)
+}
+
+fn reclista(py: Python, lista_python: Vec<i32>) -> PyResult<PyList> {
+    let lista_soma = lista_python.iter().map(|&x| x + x).collect::<Vec<i32>>();
+    let lista_retorno = lista_soma.to_py_object(py);
+    Ok(lista_retorno)
+}
+
+fn btree_mapa(py: Python) -> PyResult<PyDict> {
+    let mut dicionario_btree = BTreeMap::<String, i32>::new();
+    dicionario_btree.insert("key".to_string(), 1);
+    let py_map = dicionario_btree.to_py_object(py);
+    Ok(py_map)
+}
+
+fn rec_btree_mapa(py: Python, mapa: PyDict) -> PyResult<PyDict> {
+    let mut dicionario_btree = BTreeMap::<String, i32>::new();
+    let res = mapa.items(py);
+    for f in res.iter() {
+        dicionario_btree.insert(f.0.to_string(), f.1.to_string().parse::<i32>().unwrap()+10);
+    }
+    let ret_map = dicionario_btree.to_py_object(py);
+    Ok(ret_map)
+}
+
+py_module_initializer!(mvrpl, initmvrpl, PyInit_mvrpl, |py, m| {
+    try!(m.add(py, "__doc__", "Este modulo foi escrito em Rust."));
+    try!(m.add(py, "retpy", py_fn!(py, retpy())));
+    try!(m.add(py, "retmapa", py_fn!(py, retmapa())));
+    try!(m.add(py, "returl", py_fn!(py, returl())));
+    try!(m.add(py, "reclista", py_fn!(py, reclista(rand_int:Vec<i32>))));
+    try!(m.add(py, "mapa", py_fn!(py, btree_mapa())));
+    try!(m.add(py, "recmapa", py_fn!(py, rec_btree_mapa(rand_int:PyDict))));
+    Ok(())
+});

src/utils.rs

@@ -0,0 +1,44 @@
+extern crate cpython;
+extern crate serde_json;
+
+use cpython::*;
+use serde_json::Value;
+
+pub fn fromjson(py: Python, json: Value) -> PyObject {
+    macro_rules! obj {
+        ($x:ident) => {
+            $x.into_py_object(py).into_object()
+        }
+    }
+
+    match json {
+        Value::Number(x) => {
+            if let Some(n) = x.as_u64() {
+                obj!(n)
+            } else if let Some(n) = x.as_i64() {
+                obj!(n)
+            } else if let Some(n) = x.as_f64() {
+                obj!(n)
+            } else {
+                panic!("Número inválido")
+            }
+        }
+        Value::String(x) => PyUnicode::new(py, &x).into_object(),
+        Value::Bool(x) => obj!(x),
+        Value::Array(vec) => {
+            let mut elements = Vec::new();
+            for item in vec {
+                elements.push(fromjson(py, item));
+            }
+            PyList::new(py, &elements[..]).into_object()
+        }
+        Value::Object(map) => {
+            let dict = PyDict::new(py);
+            for (key, value) in map {
+                dict.set_item(py, key, fromjson(py, value));
+            }
+            dict.into_object()
+        }
+        Value::Null => py.None(),
+    }
+}

test.py

@@ -0,0 +1,32 @@
+import mvrpl
+import json
+
+print "------------- Retorna DocString do modulo -------------"
+print mvrpl.__doc__
+print
+
+print "------------- Retorna resultado Python -------------"
+print mvrpl.retpy()
+print
+
+print "------------- Retorna Mapa Python -------------"
+for k,v in mvrpl.retmapa().iteritems():
+    print "Chave: %s" % k
+    print "Valor: %s" % v
+    print
+
+print "------------- Retorna Lista Python -------------"
+print "__".join([str(n) for n in mvrpl.reclista([1,2,3])])
+print
+
+print "------------- Retorna resposta de URL -------------"
+print mvrpl.returl()
+print
+
+print "------------- Retorna Mapa Rust no Python -------------"
+print mvrpl.mapa()
+print
+
+print "------------- Retorna parse dict Python -------------"
+print mvrpl.recmapa({'key':15})
+print