Lolimpo/blahblah

Fake data generator for district42 schema

blahblah

Fake data generator for district42 schema

Installation

pip3 install blahblah

Usage

from blahblah import fake
from district42 import schema

UserSchema = schema.dict({
    'id': schema.int.min(1),
    'name': schema.str.regex(r"[a-z0-9_]+"),
    'is_deleted': schema.bool,
})

print(fake(UserSchema))

Documentation

• Documentation
  • None
    • schema.none
  • Bool
    • schema.bool
    • schema.bool(value)
  • Int
    • schema.int
    • schema.int(value)
    • schema.int.min(value)
    • schema.int.max(value)
  • Float
    • schema.float
    • schema.float(value)
    • schema.float.min(value)
    • schema.float.max(value)
  • Str
    • schema.str
    • schema.str.len(length)
    • schema.str.len(min_length, max_length)
    • schema.str.alphabet(letters)
    • schema.str.contains(substr)
    • schema.str.regex(pattern)
  • List
    • schema.list
    • schema.list(elements)
    • schema.list(type)
    • schema.list(type).len(length)
    • schema.list(type).len(min_length, max_length)
  • Dict
    • schema.dict
    • schema.dict(keys)
  • Any
    • schema.any
    • schema.any(*types)
  • Custom Types
    • 1. Declare Schema
    • 2. Register Generator
    • 3. Use

None

schema.none

sch = schema.none

assert fake(sch) is None

Bool

schema.bool

sch = schema.bool

assert fake(sch) in (True, False)

schema.bool(value)

sch = schema.bool(True)

assert fake(sch) is True

Int

schema.int

INT_MIN = -(2 ** 63)
INT_MAX = 2 ** 63 - 1

sch = schema.int

assert INT_MIN <= fake(sch) <= INT_MAX

schema.int(value)

sch = schema.int(42)

assert fake(sch) == 42

schema.int.min(value)

sch = schema.int.min(0)

assert 0 <= fake(sch) <= INT_MAX

schema.int.max(value)

sch = schema.int.max(0)

assert INT_MIN <= fake(sch) <= 0

Float

schema.float

sch = schema.float

assert isinstance(fake(sch), float)

schema.float(value)

sch = schema.float(3.14)

assert fake(sch) == 3.14

schema.float.min(value)

sch = schema.float.min(0.0)

assert fake(sch) >= 0.0

schema.float.max(value)

sch = schema.float.max(0.0)

assert fake(sch) <= 0.0

Str

schema.str

sch = schema.str

generated = fake(sch)
assert isinstance(generated, str)

schema.str.len(length)

sch = schema.str.len(10)

generated = fake(sch)
assert len(generated) == 10

schema.str.len(min_length, max_length)

sch = schema.str.len(1, ...)

generated = fake(sch)
assert len(generated) >= 1

sch = schema.str.len(..., 32)

generated = fake(sch)
assert len(generated) <= 32

sch = schema.str.len(1, 32)

generated = fake(sch)
assert 1 <= len(generated) <= 32

schema.str.alphabet(letters)

digits = "01234567890"
sch = schema.str.alphabet(digits)

generated = fake(sch)
assert all(x in digits for x in generated)

schema.str.contains(substr)

sch = schema.str.contains("@")

generated = fake(sch)
assert "@" in generated

schema.str.regex(pattern)

import re
sch = schema.str.regex(r"[a-z]+")

generated = fake(sch)
assert re.match(r"[a-z]+", generated)

List

schema.list

sch = schema.list

generated = fake(sch)
assert isinstance(generated, list)

schema.list(elements)

sch = schema.list([schema.int(1), schema.int(2)])

generated = fake(sch)
assert generated = [1, 2]

schema.list(type)

sch = schema.list(schema.int)

generated = fake(sch)
assert all(isinstance(x) for x in generated)

schema.list(type).len(length)

sch = schema.list(schema.int).len(3)

generated = fake(sch)
assert len(generated) == 3

schema.list(type).len(min_length, max_length)

sch = schema.list(schema.int).len(1, ...)

generated = fake(sch)
assert len(generated) >= 1

sch = schema.list(schema.int).len(..., 10)

generated = fake(sch)
assert len(generated) <= 10

sch = schema.list(schema.int).len(1, 10)

generated = fake(sch)
assert 1 <= len(generated) <= 10

Dict

schema.dict

sch = schema.dict

generated = fake(sch)
assert isinstance(generated, dict)

schema.dict(keys)

sch = schema.dict({
    "id": schema.int,
    "name": schema.str | schema.none,
    optional("platform"): schema.str,
})

generated = fake(sch)
assert isinstance(generated["id"], int)
assert isinstance(generated["name"], (str, type(None))
assert generated.keys() == {"id", "name"}

Any

schema.any

sch = schema.any

generated = fake(sch)
assert isinstance(generated, object)

schema.any(*types)

sch = schema.any(schema.str, schema.int)

generated = fake(sch)
assert isinstance(generated, (str, int))

Custom Types

1. Declare Schema

from typing import Any
from uuid import UUID
from district42 import Props, SchemaVisitor, SchemaVisitorReturnType as ReturnType
from district42.types import Schema
from niltype import Nilable


class UUIDProps(Props):
    @property
    def value(self) -> Nilable[UUID]:
        return self.get("value")


class UUIDSchema(Schema[UUIDProps]):
    def __accept__(self, visitor: SchemaVisitor[ReturnType], **kwargs: Any) -> ReturnType:
        return visitor.visit_uuid(self, **kwargs)

    def __call__(self, /, value: UUID) -> "UUIDSchema":
        return self.__class__(self.props.update(value=value))

2. Register Generator

from typing import Any
from uuid import UUID, uuid4
from blahblah import Generator
from niltype import Nil


class UUIDGenerator(Generator, extend=True):
    def visit_uuid(self, schema: UUIDSchema, **kwargs: Any) -> UUID:
        if schema.props.value is not Nil:
            return schema.props.value
        return uuid4()

3. Use

from blahblah import fake
from district42 import register_type, schema

register_type("uuid", UUIDSchema)

print(fake(schema.uuid))
# 0d9d188a-4f1f-4bce-ba6e-51ca3732900e

Full code available here: district42_exp_types/uuid