Skip to content

nxtlo/sain

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

sain

a dependency-free library which implements a few of Rust's core crates purely in Python. It offers a few of the core Rust features such as Vec<T>, Result<T, E>, Option<T> and more. See the equivalent type section below.

a few std types are implemented. Check the project documentation

Install

You'll need Python 3.10 or higher.

PyPI

pip install sain

Overview

sain provides a variety of the standard library crates. such as Vec<T> and converter interfaces.

from sain import Option, Result, Ok, Err
from sain.collections import Vec
from sain.collections.buf import Bytes
from sain.convert import Into, TryFrom

from dataclasses import dataclass, field


# A layout of some data.
@dataclass
class Layout(Into[Bytes], TryFrom[str, None]):
    tag: str
    content: str

    # converts this layout into a some raw bytes as JSON.
    def into(self) -> Bytes:
        # you probably want to use `json.dumps` here.
        return Bytes.from_str(str({"tag": self.tag, "content": self.content}))

    @classmethod
    def try_from(cls, value: str) -> Result[Layout, None]:
        # implement a conversion from a string to a layout.
        # in case of success, return Ok(layout)
        # and in case of failure, return Ok(None)
        parsed = value.split(".")  # this is an example.
        return Ok(Layout(tag=parsed[0], content=parsed[1]))


@dataclass
class Intrinsic:
    layouts: Vec[Layout] = field(default_factory=Vec)

    # extends the vec from an iterable.
    def add(self, *layouts: Layout):
        self.layouts.extend(layouts)

    # finds an optional layout that's tagged with `pattern`
    def find(self, pattern: str) -> Option[Layout]:
        return self.layouts.iter().find(lambda book: pattern in book.tag)

    # converts the entire buffer into `Bytes`
    def to_payload(self) -> Result[Bytes, None]:
        if not self.layouts:
            return Err(None)

        buffer = Bytes()
        for layout in self.layouts:
            buffer.put_bytes(layout.into())

        return Ok(buffer)


intr = Intrinsic()
intr.add(
    Layout("llm1", "content"),
)
# try to convert the string into a Layout.
match Layout.try_from("llm2.content"):
    case Ok(layout):
        intr.add(layout)  # add it if parsed.
    case Err(_):
        ...  # Error parsing the str.

print(intr.to_payload().unwrap())

built-in types

name in Rust name in Python note restrictions
Option<T>, Some(T), None Option[T], Some(T), Some(None) Some(None) has the same layout as None in Rust
Result<T, E>, Ok(T), Err(E) Result[T, E], Ok(T), Err(E)
Vec<T> Vec[T]
HashMap<K, V> HashMap[K, V]
bytes::Bytes Bytes
LazyLock<T> Lazy[T]
OnceLock<T> Once[T]
Box<T> Box[T] this isn't a heap box, See
MaybeUninit<T> MaybeUninit[T] they serve the same purpose, but slightly different
&dyn Default Default[T]
&dyn Error Error
&dyn Iterator<T> Iterator[T]
Iter<'a, T> Iter[T] collections called by .iter() are built from this type
iter::once::<T>() iter.once[T]
iter::empty::<T>() iter.empty[T]
iter::repeat::<T>() iter.repeat[T]
cfg!() cfg() runtime cfg, not all predictions are supported
#[cfg_attr] @cfg_attr() runtime cfg, not all predictions are supported
#[doc] @doc() the docs get generated at runtime
todo!() todo()
#[deprecated] @deprecated() will get removed when it get stabilized in warnings in Python 3.13
unimplemented!() @unimplemented()

Notes

Since Rust is a compiled language, Whatever predict in cfg and cfg_attr returns False will not compile.

But there's no such thing as this in Python, So RuntimeError will be raised and whatever was predicated will not run.