audeering / audobject Goto Github PK

class Object(audobject.Object):

    def __init__(
            self,
            **kwargs,
    ):
        self.foo = kwargs['foo']
        self.bar = 'not a kwarg'


o = Object(foo='a kwarg')
o.to_yaml_s()

class Base(audobject.Object):
    @audobject.init_decorator(
        resolvers={
            't': audobject.resolver.Tuple,
        }
    )
    def __init__(
            self,
            t: typing.Tuple,
    ):
        self.t = t

s = Base(t).to_yaml_s()
obj = audobject.from_yaml_s(s)
type(obj.t)

class Child(Base):
    def __init__(
            self,
            t: typing.Tuple,
    ):
        super().__init__(t)

s = Child(t).to_yaml_s()
obj = audobject.from_yaml_s(s)
type(obj.t)

class Child(Base):
    def __init__(
            self,
            t: typing.Tuple,
    ):
        super().__init__(t=t)

s = Child(t).to_yaml_s()
obj = audobject.from_yaml_s(s)
type(obj.t)

import audobject
import auglib
import numpy as np
import time

def measure_wo_serialization():
    start = time.time()
    for _ in range(100):
        signal = np.zeros((1, 16000))
        transform = auglib.transform.Tone(1000)
        transform(signal)
    end = time.time()
    print(end - start)

def measure_w_serialization():
    start = time.time()
    for _ in range(100):
        signal = np.zeros((1, 16000))
        transform = auglib.transform.Tone(1000)
        transform = audobject.from_yaml_s(transform.to_yaml_s(include_version=False))
        transform(signal)
    end = time.time()
    print(end - start)

>>> measure_wo_serialization()
0.17473506927490234
>>> measure_w_serialization()
18.60582685470581

UserWarning: TupleResolver is deprecated and will be removed with version 1.0.0. Use resolver.Tuple instead.
resolver_obj = resolve()

class MyObjectWithFunction(audobject.Object):

    @audobject.init_decorator(
        resolvers={
            'func': audobject.resolver.Function,
        }
    )
    def __init__(
            self,
            func: typing.Callable,
    ):
        self.func = func

    def __call__(self, *args, **kwargs):
        return self.func(*args, **kwargs)


def add(a, b):
    return a + b


o = MyObjectWithFunction(add)
o_yaml = o.to_yaml_s()
o2 = audobject.from_yaml_s(o_yaml)

# cannot inspect code of a dynamically defined function
o2.to_yaml_s(s)

import audobject


__version__ = "1.0.0"  # pretend we have a package version


class TestObject(audobject.Object):
    def some_method(self, some_arg: str) -> None:
        print(some_arg)


test_object = TestObject()  # test_object is an instance of TestObject
test_object.some_method("hello")  # LSP / mypy information avaliable here

test_yaml = test_object.to_yaml_s()

test_object2 = audobject.from_yaml_s(
    test_yaml
)  # test_object2 is an instance of TestObject but only known as audobject.Object

test_object2.some_method(123)  # no LSP / mypy information available here

from typing import Type, TypeVar


T = TypeVar("T", bound=audobject.Object)


def from_yaml_s_typed(
    yaml_s: str,
    instance_of: Type[T] = audobject.Object,
    **kwargs,
) -> T:
    instance = audobject.from_yaml_s(yaml_s, **kwargs)
    if not isinstance(instance, instance_of):
        raise ValueError(...)
    return instance


test_object3 = from_yaml_s_typed(
    test_yaml,
    instance_of=TestObject,
)  # test_object3 is an instance of TestObject and known as such

test_object3.some_method(123)  # LSP / mypy information available here
# mypy error: Argument 1 to "some_method" of "TestObject" has incompatible type "int"; expected "str"  [arg-type]

class Foo(audobject.Object):
@audobject.init_decorator(hide=['root'])
def __init__(self, root: str = None):
     self.root = root

bar = Foo('./test')
print(bar.root)  # shows './test'
bar = audobject.from_yaml_s(bar.to_yaml_s(), root='./test')
print(bar.root)  # shows None

class MyCallableObject:
    def __call__(self, x):
        return x * x


func = MyCallableObject()


class MyObjectWithFunction(audobject.Object):

    @audobject.init_decorator(
        resolvers={
            'func': audobject.resolver.Function,
        }
    )
    def __init__(
            self,
            func: typing.Callable,
    ):
        self.func = func

    def __call__(self, x):
        return self.func(x)


o = MyObjectWithFunction(func)
o(3)

audobject.from_yaml_s(o.to_yaml_s())

class MyCallableObject(audobject.Object):
    def __call__(self, x):
        return x * x

class Parent(audobject.Object):
    @audobject.init_decorator(
        hide=[            
            'parent',
        ],
    )
    def __init__(
            self,
            parent: bool = False,
    ):
        self.parent = parent


class Child(Parent):
    @audobject.init_decorator(
        hide=[
            'child',            
        ],
    )
    def __init__(
            self,
            child: bool = False,
            parent: bool = False,
    ):        
        super().__init__(parent=parent)
        self.child = child

c = Child()
print(c.to_yaml_s())

class MyObjectWithFunction(audobject.Object):

    @audobject.init_decorator(
        resolvers={
            'func': audobject.resolver.Function,
        }
    )
    def __init__(
            self,
            func: typing.Callable,
    ):
        self.func = func

    def __call__(self, *args, **kwargs):
        return self.func(*args, **kwargs)


def add(a, b=1):
    return a + b


o = MyObjectWithFunction(add)
o(1)  # uses b=1

o_yaml = o.to_yaml_s()
o2 = audobject.from_yaml_s(o_yaml)
o2(1)

transform = audsp.Spectrogram(...)
transform.to_yaml('transform.yaml')

audobject.Object.from_yaml('transform.yaml')
audsp.Spectrogram.from_yaml('transform.yaml')
audsp.Cepstrogram.from_yaml('transform.yaml')

audobject.from_yaml('transform')

class MyObject(audobject.Object):

    @audobject.init_decorator(
        resolvers={
            'arg': audobject.resolver.Tuple,
        }
    )
    def __init__(
            self,
            arg: typing.Tuple = None,
    ):
        super().__init__()
        self.arg = arg


MyObject().to_yaml_s(include_version=False)