Struct DataFrame

pub struct DataFrame {
    pub constants: HashMap<Key, DataValue>,
    pub dataframe: ColumnFrame,
    pub metadata: HashMap<String, DataValue>,
}

DataFrame holds information about ColumnFrame. This is used to store the data and the metadata for the candidates.

Fields

constants: HashMap<Key, DataValue>

Constants for the dataframe - mikro optimization for the data Values which is constant for the whole dataframe are stored here

dataframe: ColumnFrame

Dataframe with the candidates

metadata: HashMap<String, DataValue>

Metadata for the dataframe. Here you can store the information about the dataframe

Implementations

impl DataFrame

pub fn init() -> Self

Create a new empty DataFrame.

pub fn from_dict(df: HashMap<String, Vec<DataValue>>) -> Self

Create a DataFrame from a dictionary.

df = tdf.DataFrame.from_dict({"a": [1, 2, 3], "b": [4, 5, 6]})

pub fn keys(&self) -> Vec<String>

Returns the keys of the DataFrame.

pub fn apply(&mut self, function: Bound<'_, PyAny>) -> Result<(), PyErr>

Apply a function to the DataFrame. The function should accept a DataFrame and return a DataFrame.

def my_function(df):
   # Perform some operations on the DataFrame
  return df
/// df = tdf.DataFrame.init()
df.apply(my_function)

pub fn as_numpy_u32<'py>( &self, keys: Option<Vec<String>>, transposed: Option<bool>, py: Python<'py>, ) -> PyResult<Bound<'py, PyArray2<u32>>>

Returns slice from dataframe as numpy.array of uint32 of the given keys. If transposed is true, the keys will be transposed. If keys is None, all keys will be used.

import numpy as np
df = tdf.DataFrame.init()
df.push({"key1": 1, "key2": 2})
df.push({"key1": 11, "key2": 21})
a_np = df.as_numpy_u32(['key1', 'key2'])
assert np.array_equal(a_np, np.array([[1, 11], [2, 21]], dtype=np.uint32))

pub fn as_numpy_u64<'py>( &self, keys: Option<Vec<String>>, transposed: Option<bool>, py: Python<'py>, ) -> PyResult<Bound<'py, PyArray2<u64>>>

Returns slice from dataframe as numpy.array of uint64 of the given keys. If transposed is true, the keys will be transposed. If keys is None, all keys will be used.

import numpy as np
df = tdf.DataFrame.init()
df.push({"key1": 1, "key2": 2})
df.push({"key1": 11, "key2": 21})
a_np = df.as_numpy_u64(['key1', 'key2'])
assert np.array_equal(a_np, np.array([[1, 11], [2, 21]], dtype=np.uint64))

pub fn as_numpy_i32<'py>( &self, keys: Option<Vec<String>>, transposed: Option<bool>, py: Python<'py>, ) -> PyResult<Bound<'py, PyArray2<i32>>>

Returns slice from dataframe as numpy.array of int32 of the given keys. If transposed is true, the keys will be transposed. If keys is None, all keys will be used.

import numpy as np
df = tdf.DataFrame.init()
df.push({"key1": 1, "key2": 2})
df.push({"key1": 11, "key2": 21})
a_np = df.as_numpy_i32(['key1', 'key2'])
assert np.array_equal(a_np, np.array([[1, 11], [2, 21]], dtype=np.int32))

pub fn as_numpy_i64<'py>( &self, keys: Option<Vec<String>>, transposed: Option<bool>, py: Python<'py>, ) -> PyResult<Bound<'py, PyArray2<i64>>>

Returns slice from dataframe as numpy.array of int64 of the given keys. If transposed is true, the keys will be transposed. If keys is None, all keys will be used.

import numpy as np
df = tdf.DataFrame.init()
df.push({"key1": 1, "key2": 2})
df.push({"key1": 11, "key2": 21})
a_np = df.as_numpy_i64(['key1', 'key2'])
assert np.array_equal(a_np, np.array([[1, 11], [2, 21]], dtype=np.int64))

pub fn as_numpy_f32<'py>( &self, keys: Option<Vec<String>>, transposed: Option<bool>, py: Python<'py>, ) -> PyResult<Bound<'py, PyArray2<f32>>>

Returns slice from dataframe as numpy.array of float32 of the given keys. If transposed is true, the keys will be transposed. If keys is None, all keys will be used.

import numpy as np
df = tdf.DataFrame.init()
df.push({"key1": 1, "key2": 2})
df.push({"key1": 11, "key2": 21})
a_np = df.as_numpy_f32(['key1', 'key2'])
assert np.array_equal(a_np, np.array([[1, 11], [2, 21]], dtype=np.float32))

pub fn as_numpy_f64<'py>( &self, keys: Option<Vec<String>>, transposed: Option<bool>, py: Python<'py>, ) -> PyResult<Bound<'py, PyArray2<f64>>>

Returns slice from dataframe as numpy.array of float64 of the given keys. If transposed is true, the keys will be transposed. If keys is None, all keys will be used.

import numpy as np
df = tdf.DataFrame.init()
df.push({"key1": 1, "key2": 2})
df.push({"key1": 11, "key2": 21})
a_np = df.as_numpy_f64(['key1', 'key2'])
assert np.array_equal(a_np, np.array([[1, 11], [2, 21]], dtype=np.float64))

pub fn py_shrink(&mut self)

pub fn py_add_metadata(&mut self, key: String, value: DataValue)

pub fn py_get_metadata(&self, key: &str) -> Option<DataValue>

pub fn py_rename_key(&mut self, key: &str, new_name: &str) -> Result<(), PyErr>

pub fn py_add_alias(&mut self, key: &str, new_name: &str) -> Result<(), PyErr>

pub fn py_select<'py>( &self, py: Python<'py>, keys: Option<Vec<String>>, transposed: Option<bool>, ) -> Result<Bound<'py, PyList>, PyErr>

Selects data from the DataFrame. If keys is None, all keys will be used. If keys is provided, only the specified keys will be selected. Returns a list of lists, where each inner list represents a row of data.

import trs_dataframe as tdf
df = tdf.DataFrame.init()
df.push({"key1": 1, "key2": 2})
df.push({"key1": 11, "key2": 21})
# selected = df.select(["key1", "key2"])
# assert selected == [[1, 2], [11, 21]]
# selected = df.select()

pub fn py_select_column<'py>( &self, py: Python<'py>, key: String, ) -> Result<Bound<'py, PyList>, PyErr>

Selects a column from the DataFrame. If the column does not exist, it will raise a TypeError. Returns a list of values in the selected column.

import trs_dataframe as tdf
df = tdf.DataFrame.init()
df.push({"key1": 1, "key2": 2})
df.push({"key1": 11, "key2": 21})
# selected = df.select_column("key1")
# assert selected == [1, 11]
# selected = df.select_column("key2")
# assert selected == [2, 21]
# selected = df.select_column("non_existing_key")  # Raises TypeError

pub fn py_join( &mut self, other: DataFrame, join_type: JoinRelation, ) -> Result<(), PyErr>

Joins the current DataFrame with another DataFrame. The join type is specified by the join_type parameter. see JoinRelation for available join types.

import trs_dataframe as tdf
df1 = tdf.DataFrame.init()
df1.push({"key1": 1, "key2": 2})
df1.push({"key1": 11, "key2": 21})
df2 = tdf.DataFrame.init()
df2.push({"key1": 1, "key2": 3})
df2.push({"key1": 11, "key2": 23})
df1.join(df2, tei.JoinRelation.extend())
assert df1.select(["key1", "key2"]) == [[1, 2], [11, 21], [1, 3], [11, 23]]

pub fn py_push(&mut self, data: HashMap<Key, DataValue>) -> Result<(), PyErr>

Pushes a new row of data into the DataFrame. The data should be provided as a dictionary where keys are column names and values are the corresponding data values.

import trs_dataframe as tdf
df = tdf.DataFrame.init()
df.push({"key1": 1, "key2": 2})
df.push({"key1": 11, "key2": 21})

pub fn py_add_column( &mut self, key: Key, data: Vec<DataValue>, ) -> Result<(), PyErr>

Adds a new column to the DataFrame. The column is specified by a key and a vector of data values. If the length of the data vector does not match the number of rows in the DataFrame, it will raise a TypeError.

import trs_dataframe as tdf
df = tdf.DataFrame.init()
df.push({"key1": 1, "key2": 2})
df.push({"key1": 11, "key2": 21})
df.add_column("key3", [3, 4])
assert df.select(["key1", "key2", "key3"]) == [[1, 2, 3], [11, 21, 4]]

pub fn add_constant( &mut self, key: Key, feature: DataValue, ) -> Result<(), PyErr>

pub fn filter_by_expression( &mut self, expression: String, ) -> Result<Self, PyErr>

Filters the DataFrame by a given expression. The expression should be a string that can be parsed by the DataFrame’s filter method

import trs_dataframe as tdf
df = tdf.DataFrame.init()
df.push({"key1": 1, "key2": 2})
df.push({"key1": 11, "key2": 21})
df.filter_by_expression("key1 > 5")
assert df.select(["key1", "key2"]) == [[11, 21 ]]

pub fn __iadd__(&mut self, object: Bound<'_, PyAny>) -> Result<(), PyErr>

pub fn __isub__(&mut self, object: Bound<'_, PyAny>) -> Result<(), PyErr>

pub fn __imul__(&mut self, object: Bound<'_, PyAny>) -> Result<(), PyErr>

pub fn __itruediv__(&mut self, object: Bound<'_, PyAny>) -> Result<(), PyErr>

pub fn __len__(&mut self) -> Result<usize, PyErr>

impl DataFrame

pub fn new<C: Into<ColumnFrame>>(dataframe: C) -> Self

pub fn shrink(&mut self)

pub fn add_metadata(&mut self, key: String, value: DataValue)

pub fn get_metadata(&self, key: &str) -> Option<&DataValue>

pub fn join( &mut self, other: Self, join_type: &JoinRelation, ) -> Result<(), Error>

pub fn apply_function<F>(&mut self, keys: &[Key], func: F) -> Result<(), Error>

where F: FnMut(&[Key], &mut ColumnFrame) -> Result<(), Error>,

pub fn select(&self, keys: Option<&[Key]>) -> Result<Array2<DataValue>, Error>

pub fn select_transposed_typed<D: Extract>(&self, keys: &[Key]) -> Vec<Vec<D>>

pub fn select_column(&self, key: Key) -> Option<ArrayView1<'_, DataValue>>

pub fn select_transposed( &self, keys: Option<&[Key]>, ) -> Result<Array2<DataValue>, Error>

pub fn insert_constant(&mut self, key: Key, value: DataValue)

pub fn push<C: CandidateData>(&mut self, item: C) -> Result<(), Error>

pub fn remove_column(&mut self, keys: &[Key]) -> Result<Self, Error>

pub fn extend(&mut self, items: Self) -> Result<(), Error>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn add_single_column<K: Into<Key>>( &mut self, key: K, values: Array1<DataValue>, ) -> Result<(), Error>

pub fn get_single_column(&self, key: &Key) -> Option<ArrayView1<'_, DataValue>>

pub fn sorted(&self, key: &Key) -> Result<SortedDataFrame<'_>, Error>

pub fn filter(&self, filter: &FilterRules) -> Result<Self, Error>

Trait Implementations

impl Clone for DataFrame

fn clone(&self) -> DataFrame

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DataFrame

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DataFrame

fn default() -> DataFrame

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DataFrame

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for DataFrame

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<ColumnFrame> for DataFrame

fn from(dataframe: ColumnFrame) -> Self

Converts to this type from the input type.

impl From<HashMap<String, ArrayBase<OwnedRepr<DataValue>, Dim<[usize; 1]>>>> for DataFrame

fn from(dataframe: HashMap<String, Array1<DataValue>>) -> Self

Converts to this type from the input type.

impl From<HashMap<String, Vec<DataValue>>> for DataFrame

fn from(dataframe: HashMap<String, Vec<DataValue>>) -> Self

Converts to this type from the input type.

impl From<SizedHashMap<SmartString<LazyCompact>, Vec<DataValue>>> for DataFrame

fn from(dataframe: MLChefMap) -> Self

Converts to this type from the input type.

impl From<Vec<(Key, Vec<DataValue>)>> for DataFrame

fn from(dataframe: Vec<(Key, Vec<DataValue>)>) -> Self

Converts to this type from the input type.

impl From<Vec<HashMap<Key, DataValue>>> for DataFrame

fn from(dataframe: Vec<HashMap<Key, DataValue>>) -> Self

Converts to this type from the input type.

impl From<Vec<SizedHashMap<Key, DataValue>>> for DataFrame

fn from(dataframe: Vec<HashMap<Key, DataValue>>) -> Self

Converts to this type from the input type.

impl IntoPy<Py<PyAny>> for DataFrame

fn into_py(self, py: Python<'_>) -> PyObject

👎Deprecated since 0.23.0: IntoPy is going to be replaced by IntoPyObject. See the migration guide (https://pyo3.rs/v0.23.0/migration) for more information.

Performs the conversion.

impl<'py> IntoPyObject<'py> for DataFrame

type Target = DataFrame

The Python output type

type Output = Bound<'py, <DataFrame as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PartialEq for DataFrame

fn eq(&self, other: &DataFrame) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PyClass for DataFrame

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for DataFrame

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<DataFrame>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn doc(py: Python<'_>) -> PyResult<&'static CStr>

Rendered class doc

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyClassNewTextSignature<DataFrame> for PyClassImplCollector<DataFrame>

fn new_text_signature(self) -> Option<&'static str>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a DataFrame

type Holder = Option<PyRef<'py, DataFrame>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a mut DataFrame

type Holder = Option<PyRefMut<'py, DataFrame>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl PyMethods<DataFrame> for PyClassImplCollector<DataFrame>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for DataFrame

const NAME: &'static str = "DataFrame"

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::None

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn type_object_bound(py: Python<'_>) -> Bound<'_, PyType>

👎Deprecated since 0.23.0: renamed to PyTypeInfo::type_object

Deprecated name for PyTypeInfo::type_object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_type_of_bound(object: &Bound<'_, PyAny>) -> bool

👎Deprecated since 0.23.0: renamed to PyTypeInfo::is_type_of

Deprecated name for PyTypeInfo::is_type_of.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

fn is_exact_type_of_bound(object: &Bound<'_, PyAny>) -> bool

👎Deprecated since 0.23.0: renamed to PyTypeInfo::is_exact_type_of

Deprecated name for PyTypeInfo::is_exact_type_of.

impl Serialize for DataFrame

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl DerefToPyAny for DataFrame

impl StructuralPartialEq for DataFrame