semvec/pypi-packages huggingface dataset:
circuits-py 0.1.1
A python package for creating logic circuits.
Requires Python: >=3.6
Keywords: 'circuits logic gates'

## Circuits-py

A python package for creating logic circuits.

see [examples](https://gist.github.com/Himaghna-Senarath/6a5fda03bc9bb73142d3ead2685f1e29)

```python
from circuits_py import State

class DLatch():
    def __init__(self, Q, QI):
        self.Q = Q
        self.QI = QI
    def d_latch(self, Clock, D):
        self.Q = State(D).NOT().AND(Clock).NOR(self.QI).state
        self.QI = State(D).AND(Clock).NOR(self.Q).state

l = DLatch(1, 0)

while True:
    l.d_latch(1, 0)
```




```python
from circuits_py import State, logic, divide, combine

def addCircuit(a, b, carry):
    a = State(a)  # A State object represents current up to the next logic gate.

    divide(a.XOR(b),  # when an circuit path divides
                lambda e: e.XOR(carry),
                lambda e: a.AND(carry).OR(a.AND(b).state)
            )

addCircuit(1, 1, 0)
```

### Design

using plain functions to create circuits make it harder to understand and write:
```python
out = AND(0, AND(0, XOR(input, 0))) # gates are nested
#     <----<----<----<----<-----
#     the circuit flows in the opposite direction of the code
```

instead:

```python
State(1).XOR(0).AND(0).AND(0)
#     ----->---->---->---->
#     the circuit flows in the direction of the code

```
### State

A State object represents path of electrical current up to the next logical gate, a state can be initialized either 0 or 1.

```python
a = State(0)
b = State(1)
```

supported logic functions: AND, OR, XOR, NOT, NOR, NAND, XNOR and BUFFER

when a logic gate is invoked a new State() object is returned initialized output of that gate

```python
State(1).XOR(0).AND(1)  # returns State(1)
```

the output state can be accessed by get_output()

```python
print(State(1).XOR(0).AND(1).get_output()) # prints 1
```

### Custom Logic

use the combine() function to use custom logic,
```python
from circuits_py import combine, logic_gate

@logic_gate
def custom_logic(A, B):
    if ((A) and (not B)):
      return True
    else:
      return False

# combine() takes two or more paths and combines it to a logic function

combine(      
  State(1).AND(1),
  State(0).AND(0),      
    Logic=custom_logic  # pass the logic function
)
```

### combine()

combine two or more paths to a logic gate

example:
```python

@logic_gate
def OR(A, B):
    return A or B

combine(
    State(b).NOT().AND(a),  # source
    State(a).NOT().AND(b),  # source
        Logic=OR   # Logic function
)
```

`def combine(*sources, Logic=None)`<br>

- `*sources` State() objects,
- `Logic` a logic function which takes *source parameters and returns a `bool` output (the function should use the @logic_gate decorator)