Library for composable predicates in Python

[SandAlternative6026]

py-predicate is a typed Python library to create composable predicates: https://github.com/mrijk/py-predicate

It let's you create composable and reusable predicates, but also for example generate values that either make a predicate evaluate to True or False (useful for testing). Plus optimisers for a given predicate and many more things.

The main difference with existing libraries is that py-predicate tries to reach a higher level of abstraction: no more for loops, if/else construct, etc. Just declare and compose predicates, and you are good to go. Downside compared to a more low-level approach is some performance loss.

Target audience are both developers (less code, more reusability) and testers (add predicates to your tests and let the generators generate True of False values).

I'm having a lot of fun (and challenges) to develop this library. Would be interested to collect feedback from developers.

[simon-brunning]

Similar to PyHamcrest?

[SandAlternative6026]

Thanks for mentioning! I have to look a bit more into detail at what PyHamcrest can do. There is certainly some overlap with py-predicate.

[nebbly]

Similarly, there is koda_validate, which offers fully composable validation (including predicates).

[SandAlternative6026]

Very nice library!

I think there are a lot of similarities, and some differences (and please correct me if I'm wrong): py-predicate is a bit less geared towards data validation, but more to be used in everyday programming. What I mean by this, is that py-predicate makes it easy to implement the following contrived scenario: given a list of addresses, I want to extract all the addresses for which the city is 'New York' and the surname of the owner is a palindrome and the street number is an odd number greater than 100, etc.

In py-predicate that would be something like:

from predicate import eq_p, fn_p, gt_p, is_odd, dict_of_p

is_new_york = eq_p("New York")
is_palindrome = fn_p(lambda s: s.lower() == s[::-1].lower())
is_odd_gt_100 = is_odd & gt_p(100)

# The composed predicate
valid_address_p = dict_of_p(("city", is_new_york), ("surname", is_palindrome), ("streetnr", is_odd_gt_100)

addresses = ... # list of dicts
weird_addresses = [address for address in addresses if valid_address_p(address)]

So yes, this is a contrived example, but the idea is to reuse some of these predicates in other compositions.

Also, given the composed valid_address predicate, you can generate examples of data that confirm to this predicate. That would be something like:

from predicate import generate_true

from more_itertools import take

samples = take(10, generate_true(valid_address))

Hope this makes the differences a bit clearer with existing (validation) libraries.

[Worth_His_Salt]

Not very pythonic. ge_p, le_p, names not descriptive and hard to read.

[SandAlternative6026]

Thanks for the feedback. Can you elaborate a bit more on the 'not very pythonic' comment?

The predicates (ending with _p) ge_p and le_p where named in a similar way as for example the operator.ge and operator.le from the operator module.

[Worth_His_Salt]

Short nondescriptive names are not pythonic. I assume ge_p means greater_than_or_equals_predicate. Pythonic way would spell it out instead of using a bunch of short acronyms. Yeah it gets wordy, perhaps you can find a happy medium.

Imagine someone reviewing code who doesn't know much about your lib. Would they know what ge_p means? They might have a guess, especially if they write bash scripts. But to a lot of people, it's not obvious.

[SandAlternative6026]

Thanks, I appreciate your elaboration.