feature: initial implementation

Author: shenek

.gitignore

@@ -0,0 +1,5 @@
+**/target
+Cargo.lock
+*.pyc
+*.swo
+*.swp

CHANGELOG.rst

@@ -0,0 +1,5 @@
+0.1.0 (XXXX-XX-XX)
+------------------
+
+* extract_iter function implemented
+* initial version

Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "streamson-python"
+version = "0.1.0"
+authors = ["Stepan Henek"]
+edition = "2018"
+description = "Python wrappers around streamson"
+license = "MIT"
+readme = "README.md"
+keywords = ["json", "python", "splitter"]
+repository = "https://github.com/shenek/python-streamson"
+categories = ["parsing"]
+
+[lib]
+name = "streamson"
+crate-type = ["cdylib"]
+
+[package.metadata.maturin]
+classifier = ["Programming Language :: Python"]
+
+[dependencies]
+pyo3 = { version = "0.10", features = ["extension-module"] }
+streamson-lib = "0.2.0"

LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2020 Stepan Henek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,20 @@
+# Python streamson
+
+Python bindings for streamson. A memory efficient json splitter.
+
+## Installation
+TODO
+
+## Examples
+### Simple
+```python
+>>> import streamson
+>>> data = [b'{"users": ["john","carl","bob"]}']
+>>> extracted = streamson.extract_iter((e for e in data), ['{"users"}[]'])
+>>> for path, parsed in extracted:
+...     path, parsed
+...
+('{"users"}[0]', 'john')
+('{"users"}[1]', 'carl')
+('{"users"}[2]', 'bob')
+```

pyproject.toml

@@ -0,0 +1,7 @@
+[build-system]
+requires = ["maturin"]
+build-backend = "maturin"
+
+[tool.maturin]
+bindings = "pyo3"
+manylinux = "2014"

src/lib.rs

@@ -0,0 +1,79 @@
+use pyo3::prelude::*;
+use pyo3::create_exception;
+use pyo3::wrap_pyfunction;
+use pyo3::types::{PyBytes, PyTuple};
+use pyo3::exceptions;
+
+use std::sync::{Arc, Mutex};
+use streamson_lib::{error, handler, matcher, Collector};
+
+create_exception!(streamson, StreamsonError, exceptions::ValueError);
+
+impl From<error::General> for StreamsonError {
+    fn from(gerror: error::General) -> Self {
+        Self
+    }
+}
+
+/// Low level Python wrapper for Simple matcher and Buffer handler
+#[pyclass]
+pub struct SimpleStreamson {
+    collector: Collector,
+    handler: Arc<Mutex<handler::Buffer>>,
+}
+
+#[pymethods]
+impl SimpleStreamson {
+
+    /// Create a new instance of SimpleStreamson
+    ///
+    /// # Arguments
+    /// * `matches` - a list of valid simple matches (e.g. `{"users"}`, `[]{"name"}`, `[0]{}`)
+    #[new]
+    pub fn new(matches: Vec<String>) -> Self {
+        let handler = Arc::new(Mutex::new(handler::Buffer::new()));
+        let mut collector = Collector::new();
+        for path_match in matches {
+            collector = collector.add_matcher(
+                Box::new(matcher::Simple::new(path_match)),
+                &[handler.clone()],
+            );
+        }
+        Self { collector, handler }
+    }
+
+    /// Feeds Streamson processor with data
+    ///
+    /// # Arguments
+    /// * `data` - input data to be processed
+    pub fn feed(&mut self, data: &[u8]) -> PyResult<()> {
+        if let Err(err) = self.collector.process(data) {
+            Err(StreamsonError::from(err).into())
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Reads data from Buffer handler
+    ///
+    /// # Returns
+    /// * `None` - if no data present
+    /// * `Some(<path>, <bytes>)` if there are some data
+    fn pop(&mut self) -> Option<(String, Vec<u8>)>{
+
+        match self.handler.lock().unwrap().pop() {
+            Some((path, bytes)) => {
+                Some((path, bytes.to_vec()))
+            },
+            None => None,
+        }
+
+    }
+}
+/// This module is a python module implemented in Rust.
+#[pymodule]
+fn streamson(py: Python, m: &PyModule) -> PyResult<()> {
+    m.add_class::<SimpleStreamson>()?;
+
+    Ok(())
+}

streamson/__init__.py

@@ -0,0 +1,26 @@
+import json
+import typing
+
+from array import array
+
+from streamson.streamson import SimpleStreamson as _SimpleStreamson
+
+
+def extract_iter(
+    input_gen: typing.Generator[bytes, None, None],
+    simple_matches: typing.List[str],
+) -> typing.Generator[typing.Tuple[str, typing.Any], None, None]:
+    """ Extracts json specified by givem list of simple matches
+    :param: input_gen - input generator
+    :param: simple_matches - matches to check
+
+    :returns: (string, data) generator
+    """
+    streamson = _SimpleStreamson(simple_matches)
+    for item in input_gen:
+        streamson.feed(item)
+        res = streamson.pop()
+        while res is not None:
+            path, data = res
+            yield path, json.loads(array('B', data).tobytes())
+            res = streamson.pop()