py-rs 0.1.1

generate python bindings from rust types
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

#![allow(dead_code)]

use std::time::Instant;

#[cfg(feature = "serde-compat")]
use serde::Serialize;
use py_rs::PY;

struct Unsupported<T>(T);
struct Unsupported2;

#[derive(PY)]
#[py(export, export_to = "type_override/")]
struct Override {
    a: i32,
    #[py(type = "0 | 1 | 2")]
    b: i32,
    #[py(type = "string")]
    x: Instant,
    #[py(type = "string")]
    y: Unsupported<Unsupported<Unsupported2>>,
    #[py(type = "string | null")]
    z: Option<Unsupported2>,
}

#[test]
fn simple() {
    assert_eq!(
        Override::inline(),
        "{ a: number, b: 0 | 1 | 2, x: string, y: string, z: string | null, }"
    )
}

#[derive(PY)]
#[py(export, export_to = "type_override/")]
struct New1(#[py(type = "string")] Unsupported2);

#[derive(PY)]
#[py(export, export_to = "type_override/")]
struct New2(#[py(type = "string | null")] Unsupported<Unsupported2>);

#[test]
fn newtype() {
    assert_eq!(New1::inline(), r#"string"#);
    assert_eq!(New2::inline(), r#"string | null"#);
}

#[cfg_attr(feature = "serde-compat", derive(Serialize))]
struct S;

#[derive(PY)]
#[cfg_attr(feature = "serde-compat", derive(Serialize))]
#[cfg_attr(feature = "serde-compat", serde(tag = "t"))]
#[cfg_attr(not(feature = "serde-compat"), py(tag = "t"))]
#[py(export, export_to = "type_override/")]
enum Internal {
    Newtype(#[py(type = "unknown")] S),
}

#[derive(PY)]
#[cfg_attr(feature = "serde-compat", derive(Serialize))]
#[cfg_attr(feature = "serde-compat", serde(tag = "t", content = "c"))]
#[cfg_attr(not(feature = "serde-compat"), py(tag = "t", content = "c"))]
#[py(export, export_to = "type_override/")]
enum Adjacent {
    Newtype(#[py(type = "unknown")] S),
}

#[test]
fn enum_newtype_representations() {
    // regression test for https://github.com/Aleph-Alpha/ts-rs/issues/126
    assert_eq!(Internal::inline(), r#"{ "t": "Newtype" } & unknown"#);
    assert_eq!(Adjacent::inline(), r#"{ "t": "Newtype", "c": unknown }"#);
}