BooleanSolver
Introduction
A picture is worth a thousand words and a vid is worth a thousand pictures, so watch a short intro or continue reading...
This is a python 2 project to speed up boolean expression coding. Sometimes we need to crack a problem by combining boolean operators such as: and
, or
& not
. We as humans are prone to err, specially when expressions get big. But there is an algorithm (QuineMcCluskey) to get this expressions with zero error. Just specify your specs in a test and set a dummy function on your code. When you run your tests a solver will take your specs and code them into a simple boolean expression, enjoy :).
This same boolean logic is being expanded to a broader range of problems check other coding capabilities below.
Package Setup

Install BooleanSolver package:
$ pip install BooleanSolver
Short Example
Add new script(start.py
) with a mock function:
from boolean_solver import solver as s
@s.solve()
def and_function(a, b):
pass
Add a unittest(test.py
) with specs:
import unittest
from boolean_solver import solver
import start
class MyTest(unittest.TestCase):
"""
1. Set conditions of your boolean function (for True outputs)
2. Run solver.execute(self, callable, table) where callable is the boolean function
with the decorator=@solve().
See examples below:
"""
def test_AND_function(self):
# The output is explicitly set to true
cond = solver.Conditions(a=True, b=True, output=True)
solver.execute(self, start.and_function, cond)
Then run $ python m unittest test
. In start.py
the result should be:
def and_function(a, b):
return a and b
NonBoolean outputs
What if the output for a given logical condition is not a boolean. In that case a programmer would use an if. In the next example this package solves this case automatically:
Add if_function(a, b)
to start.py
:
@s.solve()
def if_function(a, b):
pass
Add test_ifs(self)
to MyTest(unittest.TestCase)
class in test.py
:
def test_ifs(self):
"""
Testing ifs.
"""
cond = solver.Conditions(a=False, b=True, output=1) # nonboolean output
cond.add(a=True, b=False, output=0) # nonboolean output
solver.execute(self, start.if_function, cond)
Then run $ python m unittest test
, the result should be:
def if_function(a, b):
if not a and b:
return 1
if a and not b:
return 0
return False
Now, some cool coding
Add recursive(a)
to start.py
:
@s.solve()
def recursive(a):
pass
Add test_recursive_function(self)
to MyTest(unittest.TestCase)
class in test.py
:
def test_recursive_function(self):
"""
Will do recursion, extremely cool!!!
"""
args = {'a': solver.Code('not a')}
out = solver.Output(start.recursive, args)
cond = solver.Conditions(a=False, output=0, default=out)
solver.execute(self, start.recursive, cond)
The result this time will be a recursive function :)
def recursive(a):
if not a:
return 0
return recursive(not a)
Expression behaving like boolean inputs
Say you want to add a piece of code that evaluates to boolean, then:
Add with_internal_code(a)
to start.py
:
@s.solve()
def with_internal_code(a):
pass
Add test_internal_code(self)
to MyTest(unittest.TestCase)
class in test.py
:
def test_internal_code(self):
"""
Testing internal pieces of code
"""
cond = solver.Conditions(any_non_input_name=solver.Code('isinstance(a, str)'), output=2)
solver.execute(self, start.internal_code, cond)
The result should be:
def internal_code(a):
if isinstance(a, str):
return 2
return False
Source Code
Setup with source code
 Clone repository:
git clone git@github.com:jisazaTappsi/BooleanSolver.git
Intro Example with source code
Enter
boolean_solver
:cd boolean_solver

Run:
python start_sample.py
Sorry, run: python m unittest test_sample first, to solve the riddle :)

So, run test with:
python m unittest test_sample
Solved and tested and_function_3_variables .Solved and tested and_function .Solved and tested or_function .Solved and tested xor_function .  Ran 4 tests in 0.006s OK

Run:
python start_sample.py
You made it, Congrats !!! Now, see the functions, enjoy :)
You just solved 4 boolean expressions: and
, or
, xor
& and3
. Specs for these functions are in test_sample.py
.
How does Boolean Solver works?
Takes a function and a truth_table which is processed using the QuineMcCluskey Algorithm. Then finds a optimal boolean expression. This expression is inserted in the method definition with the decorator @boolean_solver()
.
solver.execute(test, function, conditions)
Arguments of The test case itself, to be able to perform tests, eg:
self
A function to optimize, passed as a callable (with no arguments). This function needs a 3 mock line definition with: line 1: decorator =
@solve()
line 2: signature eg:def my_function(a, b)
line 3: body: only one line, eg:return False
. This line will be replaced by the boolean expression.
a.
solver.Conditions()
instance: An object that can handle logical conditions with named arguments eg:cond = solver.Conditions(a=True, b=False) cond.add(a=True, b=True)
The reserved word
output
allows:cond.add(a=False, b=False, output=False)
Meaning that when
a=False, b=False
I want theoutput
to beFalse
b. Truth table: Alternatively a truth table can be specified (as a set containing tuples). Where each row is a tuple, the general form is:
{tuple_row(tuple_inputs(a, b, ...), output), ...}
or with a implicit
True
output:{tuple_inputs(a, b, ...), ...}
solver.Conditions() and cond.add()
Arguments of These are specified as a dictionary containing certain keywords as well as the function inputs.
Keywords are:
output
: Determines the value to be returned when the given condition is True.
output_args
: Dictionary with the values for the arguments when output is a function.
default
: Value returned when non of the conditions are True.
Helper Classes
solver.Output
: Class that helps define a function with arguments as an output. Has fields:

function
: A callable object. 
arguments
Dictionary with the function inputs.
solver.Code
: Class that helps output pieces of code. The code is given as a String.
solver.Solution
: Class that contains the solution of the problem it includes:

conditions
: The information given by the user. 
implementation
: Plain code. 
ast
: Abstract syntax tree