Python re Examples

Example #1

 def foo(*,
         k: tc.map_of(
             (int, int),
             [tc.re("^[0-9]+$"), tc.re("^[0-9]+$")])):
     return functools.reduce(
         lambda r, t: r and str(t[0][0]) == t[1][0] and str(t[0][1]) == t[1]
         [1], k.items(), True)

Example #2

def test_has6():
    assert tc.re("^123$")("123") and tc.re("^123$").check("123")
    assert not tc.re("^123$")("foo") and not tc.re("^123$").check("foo")

Example #3

File: test_typecheck_decorator.py Project: dollarshaveclub/typecheck-decorator

def test_seq_of_with_optional():
    assert tc.seq_of(tc.optional(tc.re("^foo$")))(["foo", None, "foo"]) and \
           tc.seq_of(tc.optional(tc.re("^foo$"))).check(["foo", None, "foo"])
    assert not tc.seq_of(tc.optional(tc.re("^foo$")))(["123", None, "foo"]) and \
           not tc.seq_of(tc.optional(tc.re("^foo$"))).check(["foo", None, "1234"])

Example #4

File: test_typecheck_decorator.py Project: dollarshaveclub/typecheck-decorator

def test_has6():
    assert tc.re("^123$")("123") and tc.re("^123$").check("123")
    assert not tc.re("^123$")("foo") and not tc.re("^123$").check("foo")

Example #5

File: test_typecheck_decorator.py Project: dollarshaveclub/typecheck-decorator

 def foo(s: tc.re("^[{0}]$".format(russian))):
     return len(s)

Example #6

File: test_typecheck_decorator.py Project: dollarshaveclub/typecheck-decorator

 def foo(*, k: tc.re("^[0-9A-F]+$")) -> tc.re("^[0-9]+$"):
     return "".join(reversed(k))

Example #7

File: test_typecheck_decorator.py Project: dollarshaveclub/typecheck-decorator

 def taboo(x: tc.none(tc.re("foo"), tc.re("bar"))):
     pass

Example #8

File: test_typecheck_decorator.py Project: dollarshaveclub/typecheck-decorator

 def accept_number(x: tc.any(int, tc.re("^[0-9]+$"))):
     return int(x) + 1

Example #9

 def numbers_only_please(s: tc.re("^[0-9]+$")):
     pass

Example #10

 def foo(s: tc.re("^[{0}]$".format(russian))):
     return len(s)

Example #11

 def foo(*, k: (tc.re("^1$"), [tc.re("^x$"), tc.re("^y$")])):
     return k[0] + k[1][0] + k[1][1]

Example #12

 def foo(*, k: tc.re("^[0-9A-F]+$")) -> tc.re("^[0-9]+$"):
     return "".join(reversed(k))

Example #13

def test_has1():
    namespace = None
    assert tc.re("^abc$")("abc", namespace)
    assert not tc.re("^abc$")(b"abc", namespace)
    assert not tc.re(b"^abc$")("abc", namespace)
    assert tc.re(b"^abc$")(b"abc", namespace)
    assert tc.re(b"^foo\x00bar$")(b"foo\x00bar", namespace)
    assert not tc.re(b"^foo\x00bar$")(b"foo\x00baz", namespace)
    assert tc.re("^abc")("abc\n", namespace)
    assert tc.re(b"^abc")(b"abc\n", namespace)
    assert not tc.re("^abc$")("abc\n", namespace)
    assert not tc.re(b"^abc$")(b"abc\n", namespace)
    assert not tc.re("^abc$")("abcx", namespace)
    assert not tc.re(b"^abc$")(b"abcx", namespace)

Example #14

File: test_tc_predicates.py Project: flying-sheep/typecheck-decorator

def test_has6():
    namespace = None
    assert tc.re("^123$")("123", namespace)
    assert tc.re("^123$").check("123", namespace)
    assert not tc.re("^123$")("foo", namespace)
    assert not tc.re("^123$").check("foo", namespace)

Example #15

File: test_tc_predicates.py Project: flying-sheep/typecheck-decorator

def test_has1():
    namespace = None
    assert tc.re("^abc$")("abc", namespace)
    assert not tc.re("^abc$")(b"abc", namespace)
    assert not tc.re(b"^abc$")("abc", namespace)
    assert tc.re(b"^abc$")(b"abc", namespace)
    assert tc.re(b"^foo\x00bar$")(b"foo\x00bar", namespace)
    assert not tc.re(b"^foo\x00bar$")(b"foo\x00baz", namespace)
    assert tc.re("^abc")("abc\n", namespace)
    assert tc.re(b"^abc")(b"abc\n", namespace)
    assert not tc.re("^abc$")("abc\n", namespace)
    assert not tc.re(b"^abc$")(b"abc\n", namespace)
    assert not tc.re("^abc$")("abcx", namespace)
    assert not tc.re(b"^abc$")(b"abcx", namespace)

Example #16

 def taboo(x: tc.none(tc.re("foo"), tc.re("bar"))):
     pass

Example #17

File: test_typecheck_decorator.py Project: dollarshaveclub/typecheck-decorator

 def bar(x: tc.any((int, float), tc.re("^foo$"), tc.enum(b"X", b"Y"))):
     pass

Example #18

def test_has6():
    namespace = None
    assert tc.re("^123$")("123", namespace)
    assert tc.re("^123$").check("123", namespace)
    assert not tc.re("^123$")("foo", namespace)
    assert not tc.re("^123$").check("foo", namespace)

Example #19

File: test_typecheck_decorator.py Project: dollarshaveclub/typecheck-decorator

 def bar(x: tc.all(tc.re("abcdef"), tc.re("defghi"), tc.re("^abc"))):
     pass

Example #20

 def foo(x: tc.seq_of((tc.re("^[01]+$"), int))) -> bool:
     return functools.reduce(lambda r, e: r and int(e[0], 2) == e[1], x,
                             True)

Example #21

File: test_typecheck_decorator.py Project: dollarshaveclub/typecheck-decorator

def test_has1():
    assert tc.re("^abc$")("abc")
    assert not tc.re("^abc$")(b"abc")
    assert not tc.re(b"^abc$")("abc")
    assert tc.re(b"^abc$")(b"abc")
    assert tc.re(b"^foo\x00bar$")(b"foo\x00bar")
    assert not tc.re(b"^foo\x00bar$")(b"foo\x00baz")
    assert tc.re("^abc")("abc\n")
    assert tc.re(b"^abc")(b"abc\n")
    assert not tc.re("^abc$")("abc\n")
    assert not tc.re(b"^abc$")(b"abc\n")
    assert not tc.re("^abc$")("abcx")
    assert not tc.re(b"^abc$")(b"abcx")

Example #22

def test_seq_of_with_optional():
    namespace = None
    assert tc.seq_of(tc.optional(tc.re("^foo$")))(["foo", None, "foo"], namespace) and \
           tc.seq_of(tc.optional(tc.re("^foo$"))).check(["foo", None, "foo"], namespace)
    assert not tc.seq_of(tc.optional(tc.re("^foo$")))(["123", None, "foo"], namespace) and \
           not tc.seq_of(tc.optional(tc.re("^foo$"))).check(["foo", None, "1234"], namespace)

Example #23

File: test_typecheck_decorator.py Project: dollarshaveclub/typecheck-decorator

 def foo(*, k: (tc.re("^1$"), [tc.re("^x$"), tc.re("^y$")])):
     return k[0] + k[1][0] + k[1][1]

Example #24

 def bar(x: tc.any((int, float), tc.re("^foo$"), tc.enum(b"X", b"Y"))):
     pass

Example #25

File: test_typecheck_decorator.py Project: dollarshaveclub/typecheck-decorator

 def numbers_only_please(s: tc.re("^[0-9]+$")):
     pass

Example #26

 def accept_number(x: tc.any(int, tc.re("^[0-9]+$"))):
     return int(x) + 1

Example #27

File: test_typecheck_decorator.py Project: dollarshaveclub/typecheck-decorator

 def foo(x: tc.seq_of((tc.re("^[01]+$"), int))) -> bool:
     return functools.reduce(lambda r, e: r and int(e[0], 2) == e[1],
                             x, True)

Example #28

 def bar(x: tc.all(tc.re("abcdef"), tc.re("defghi"), tc.re("^abc"))):
     pass

Example #29

File: test_typecheck_decorator.py Project: dollarshaveclub/typecheck-decorator

 def foo(*, k: tc.map_of((int, int), [tc.re("^[0-9]+$"), tc.re("^[0-9]+$")])):
     return functools.reduce(lambda r, t: r and str(t[0][0]) == t[1][0] and str(t[0][1]) == t[1][1],
                             k.items(), True)

Example #30

def test_has1():
    assert tc.re("^abc$")("abc")
    assert not tc.re("^abc$")(b"abc")
    assert not tc.re(b"^abc$")("abc")
    assert tc.re(b"^abc$")(b"abc")
    assert tc.re(b"^foo\x00bar$")(b"foo\x00bar")
    assert not tc.re(b"^foo\x00bar$")(b"foo\x00baz")
    assert tc.re("^abc")("abc\n")
    assert tc.re(b"^abc")(b"abc\n")
    assert not tc.re("^abc$")("abc\n")
    assert not tc.re(b"^abc$")(b"abc\n")
    assert not tc.re("^abc$")("abcx")
    assert not tc.re(b"^abc$")(b"abcx")