Chore/Rename Nada Algebra to Nada Numpy (#35)

* chore!: renamed nada_algebra to nada_numpy

* chore: changed target pypi repository to Nillion

Author: jcabrero

.github/workflows/python-publish.yml

@@ -29,5 +29,5 @@ jobs:
       run: poetry build
     - name: Publish package
       run: |
-        poetry config pypi-token.pypi ${{ secrets.PYPI_TOKEN }}
+        poetry config pypi-token.pypi ${{ secrets.NILLION_PYPI_TOKEN }}
         poetry publish

.github/workflows/test.yml

@@ -1,7 +1,7 @@
 # This workflow will install Python dependencies, run tests and lint with a variety of Python versions
 # For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
 
-name: Test Nada Algebra
+name: Test Nada Numpy
 
 on:
   push:
@@ -24,9 +24,9 @@ jobs:
         pip install poetry
         poetry install --with dev
     - name: Run pylint
-      run: poetry run pylint nada_algebra
+      run: poetry run pylint nada_numpy
     - name: Run mypy
-      run: poetry run mypy nada_algebra
+      run: poetry run mypy nada_numpy
 
   build:
     needs: check-linting

README.md

@@ -1,10 +1,10 @@
-# Nada-Algebra
+# Nada-Numpy
 
-![GitHub License](https://img.shields.io/github/license/NillionNetwork/nada-algebra?style=for-the-badge)
-![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/NillionNetwork/nada-algebra/test?style=for-the-badge)
+![GitHub License](https://img.shields.io/github/license/NillionNetwork/nada-numpy?style=for-the-badge)
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/NillionNetwork/nada-numpy/test?style=for-the-badge)
 
 
-Nada-Algebra is a Python library designed for algebraic operations on NumPy-like array objects on top of Nada DSL and Nillion Network. It provides a simple and intuitive interface for performing various algebraic computations, including dot products, element-wise operations, and stacking operations, while supporting broadcasting similar to NumPy arrays.
+Nada-Numpy is a Python library designed for algebraic operations on NumPy-like array objects on top of Nada DSL and Nillion Network. It provides a simple and intuitive interface for performing various algebraic computations, including dot products, element-wise operations, and stacking operations, while supporting broadcasting similar to NumPy arrays.
 
 ## Features
 
@@ -19,16 +19,24 @@ Nada-Algebra is a Python library designed for algebraic operations on NumPy-like
 ### Using pip
 
 ```bash
-pip install nada-algebra
+pip install nada-numpy
 ```
 
 ### From Sources
-You can install the nada-algebra library using Poetry:
+You can install the nada-numpy library using Poetry:
 
 ```bash
-git clone https://github.com/NillionNetwork/nada-algebra.git
-pip3 install poetry
-poetry install nada-algebra
+git clone https://github.com/NillionNetwork/nada-numpy.git
+pip3 install ./nada-numpy
+```
+
+## Testing
+
+To test that the version installed works as expected, you can use poetry as follows:
+
+```bash
+poetry install
+poetry run pytest
 ```
 
 ## License

examples/broadcasting/README.md

@@ -1,29 +1,29 @@
 # Broadcasting Tutorial
 
-This tutorial shows how to efficiently use broadcasting in Nada using Nada Algebra. 
+This tutorial shows how to efficiently use broadcasting in Nada using Nada Numpy. 
 
 ```python
 from nada_dsl import *
 
-# Step 0: Nada Algebra is imported with this line
-import nada_algebra as na
+# Step 0: Nada Numpy is imported with this line
+import nada_numpy as na
 
 
 def nada_main():
-    # Step 1: We use Nada Algebra wrapper to create "Party0", "Party1" and "Party2"
+    # Step 1: We use Nada Numpy wrapper to create "Party0", "Party1" and "Party2"
     parties = na.parties(3)
 
     # Step 2: Party0 creates an array of dimension (3, ) with name "A"
-    a = na.array([3], parties[0], "A")
+    a = na.array([3], parties[0], "A", SecretInteger)
 
     # Step 3: Party1 creates an array of dimension (3, ) with name "B"
-    b = na.array([3], parties[1], "B")
+    b = na.array([3], parties[1], "B", SecretInteger)
 
     # Step 4: Party0 creates an array of dimension (3, ) with name "C"
-    c = na.array([3], parties[0], "C")
+    c = na.array([3], parties[0], "C", SecretInteger)
 
     # Step 5: Party1 creates an array of dimension (3, ) with name "D"
-    d = na.array([3], parties[1], "D")
+    d = na.array([3], parties[1], "D", SecretInteger)
 
     # Step 4: The result is of computing SIMD operations on top of the elements of the array
     # SIMD operations are performed on all the elements of the array.
@@ -33,13 +33,13 @@ def nada_main():
     return result.output(parties[2], "my_output")
 ```
 
-0. We import Nada algebra using `import nada_algebra as na`.
+0. We import Nada Numpy using `import nada_numpy as na`.
 1. We create an array of parties, with our wrapper using `parties = na.parties(3)` which creates an array of parties named: `Party0`, `Party1` and `Party2`.
 2. We create our input array `a` with `na.array([3], parties[0], "A")`, meaning our array will have dimension 3, `Party0` will be in charge of giving its inputs and the name of the variable is `"A"`.
 3. We create our input array `b` with `na.array([3], parties[1], "B")`, meaning our array will have dimension 3, `Party1` will be in charge of giving its inputs and the name of the variable is `"B"`.
 4. We create our input array `c` with `na.array([3], parties[1], "C")`, meaning our array will have dimension 3, `Party0` will be in charge of giving its inputs and the name of the variable is `"C"`.
 5. We create our input array `d` with `na.array([3], parties[1], "D")`, meaning our array will have dimension 3, `Party1` will be in charge of giving its inputs and the name of the variable is `"D"`.
-5. Finally, we use Nada Algebra to produce the outputs of the array like:  `result.output(parties[2], "my_output")` establishing that the output party will be `Party2`and the name of the output variable will be `my_output`. 
+5. Finally, we use Nada Numpy to produce the outputs of the array like:  `result.output(parties[2], "my_output")` establishing that the output party will be `Party2`and the name of the output variable will be `my_output`. 
 # How to run the tutorial.
 
 1. First, we need to compile the nada program running: `nada build`.

examples/broadcasting/main.py

@@ -7,12 +7,15 @@
 import py_nillion_client as nillion
 from dotenv import load_dotenv
 
-import nada_algebra.client as na_client
+import nada_numpy.client as na_client
+
 # Import helper functions for creating nillion client and getting keys
 from examples.broadcasting.config import DIM
 from examples.common.nillion_client_helper import create_nillion_client
-from examples.common.nillion_keypath_helper import (getNodeKeyFromFile,
-                                                    getUserKeyFromFile)
+from examples.common.nillion_keypath_helper import (
+    getNodeKeyFromFile,
+    getUserKeyFromFile,
+)
 from examples.common.utils import compute, store_program, store_secrets
 
 # Load environment variables from a .env file

examples/broadcasting/src/broadcasting.py

@@ -4,7 +4,8 @@
 
 from nada_dsl import Output, SecretInteger
 
-import nada_algebra as na
+# Step 0: Nada Numpy is imported with this line
+import nada_numpy as na
 
 
 def nada_main() -> List[Output]:
@@ -14,7 +15,7 @@ def nada_main() -> List[Output]:
     Returns:
         List[Output]: List of Nada outputs.
     """
-    # Step 1: We use Nada Algebra wrapper to create "Party0", "Party1" and "Party2"
+    # Step 1: We use Nada Numpy wrapper to create "Party0", "Party1" and "Party2"
     parties = na.parties(3)
 
     # Step 2: Party0 creates an array of dimension (3, ) with name "A"

examples/common/nillion_payments_helper.py

@@ -7,7 +7,7 @@
 import numpy as np
 import py_nillion_client as nillion
 
-import nada_algebra.client as na_client
+import nada_numpy.client as na_client
 
 
 def async_timer(file_path: os.PathLike) -> Callable:

examples/common/utils.py

@@ -1,16 +1,16 @@
 # Dot Product Tutorial
 
-This tutorial shows how to efficiently program a dot product in Nada using Nada Algebra. 
+This tutorial shows how to efficiently program a dot product in Nada using Nada Numpy. 
 
 ```python
 from nada_dsl import *
 
-# Step 0: Nada Algebra is imported with this line
-import nada_algebra as na
+# Step 0: Nada Numpy is imported with this line
+import nada_numpy as na
 
 
 def nada_main():
-    # Step 1: We use Nada Algebra wrapper to create "Party0", "Party1" and "Party2"
+    # Step 1: We use Nada Numpy wrapper to create "Party0", "Party1" and "Party2"
     parties = na.parties(3)
 
     # Step 2: Party0 creates an array of dimension (3, ) with name "A"
@@ -24,15 +24,14 @@ def nada_main():
 
     # Step 5: We can use result.output() to produce the output for Party2 and variable name "my_output"
     return na.output(result, parties[1], "my_output")
-
 ```
 
-0. We import Nada algebra using `import nada_algebra as na`.
+0. We import Nada Numpy using `import nada_numpy as na`.
 1. We create an array of parties, with our wrapper using `parties = na.parties(3)` which creates an array of parties named: `Party0`, `Party1` and `Party2`.
 2. We create our input array `a` with `na.array([3], parties[0], "A")`, meaning our array will have dimension 3, `Party0` will be in charge of giving its inputs and the name of the variable is `"A"`.
 3. We create our input array `b` with `na.array([3], parties[1], "B")`, meaning our array will have dimension 3, `Party1` will be in charge of giving its inputs and the name of the variable is `"B"`.
 4. Then, we use the `dot` function to compute the dot product like `a.dot(b)`, which will encompass all the functionality.
-5. Finally, we use Nada Algebra to produce the outputs of the array like:  `result.output(parties[2], "my_output")` establishing that the output party will be `Party2`and the name of the output variable will be `my_output`. 
+5. Finally, we use Nada Numpy to produce the outputs of the array like:  `result.output(parties[2], "my_output")` establishing that the output party will be `Party2`and the name of the output variable will be `my_output`. 
 # How to run the tutorial.
 
 1. First, we need to compile the nada program running: `nada build`.

examples/dot_product/README.md

@@ -8,11 +8,14 @@
 import py_nillion_client as nillion
 from dotenv import load_dotenv
 
-import nada_algebra.client as na_client
+import nada_numpy.client as na_client
+
 # Import helper functions for creating nillion client and getting keys
 from examples.common.nillion_client_helper import create_nillion_client
-from examples.common.nillion_keypath_helper import (getNodeKeyFromFile,
-                                                    getUserKeyFromFile)
+from examples.common.nillion_keypath_helper import (
+    getNodeKeyFromFile,
+    getUserKeyFromFile,
+)
 from examples.common.utils import compute, store_program, store_secrets
 from examples.dot_product.config import DIM
 

examples/dot_product/main.py

@@ -4,7 +4,8 @@
 
 from nada_dsl import Output, SecretInteger
 
-import nada_algebra as na
+# Step 0: Nada Numpy is imported with this line
+import nada_numpy as na
 
 
 def nada_main() -> List[Output]:
@@ -14,7 +15,7 @@ def nada_main() -> List[Output]:
     Returns:
         List[Output]: List of program outputs.
     """
-    # Step 1: We use Nada Algebra wrapper to create "Party0", "Party1" and "Party2"
+    # Step 1: We use Nada Numpy wrapper to create "Party0", "Party1" and "Party2"
     parties = na.parties(3)
 
     # Step 2: Party0 creates an array of dimension (3, ) with name "A"

examples/dot_product/src/dot_product.py

@@ -1,22 +1,23 @@
 # Matrix Multiplication Tutorial
 
-This tutorial shows how to efficiently program a matrix multiplication in Nada using Nada Algebra. 
+This tutorial shows how to efficiently program a matrix multiplication in Nada using Nada Numpy. 
 
 ```python
 from nada_dsl import *
-# Step 0: Nada Algebra is imported with this line
-import nada_algebra as na
+
+# Step 0: Nada Numpy is imported with this line
+import nada_numpy as na
 
 
 def nada_main():
-    # Step 1: We use Nada Algebra wrapper to create "Party0", "Party1" and "Party2"
+    # Step 1: We use Nada Numpy wrapper to create "Party0", "Party1" and "Party2"
     parties = na.parties(3)
 
     # Step 2: Party0 creates an array of dimension (3 x 3) with name "A"
-    a = na.array([3, 3], parties[0], "A")
+    a = na.array([3, 3], parties[0], "A", SecretInteger)
 
     # Step 3: Party1 creates an array of dimension (3 x 3) with name "B"
-    b = na.array([3, 3], parties[1], "B")
+    b = na.array([3, 3], parties[1], "B", SecretInteger)
 
     # Step 4: The result is of computing the dot product between the two which is another (3 x 3) matrix
     result = a @ b
@@ -26,12 +27,12 @@ def nada_main():
 
 ```
 
-0. We import Nada algebra using `import nada_algebra as na`.
+0. We import Nada Numpy using `import nada_numpy as na`.
 1. We create an array of parties, with our wrapper using `parties = na.parties(3)` which creates an array of parties named: `Party0`, `Party1` and `Party2`.
 2. We create our input array `a` with `na.array([3], parties[0], "A")`, meaning our array will have dimension 3, `Party0` will be in charge of giving its inputs and the name of the variable is `"A"`.
 3. We create our input array `b` with `na.array([3], parties[1], "B")`, meaning our array will have dimension 3, `Party1` will be in charge of giving its inputs and the name of the variable is `"B"`.
 4. Then, we use the `dot` function to compute the dot product like `a.dot(b)`, which will encompass all the functionality.
-5. Finally, we use Nada Algebra to produce the outputs of the array like:  `result.output(parties[2], "my_output")` establishing that the output party will be `Party2`and the name of the output variable will be `my_output`. 
+5. Finally, we use Nada Numpy to produce the outputs of the array like:  `result.output(parties[2], "my_output")` establishing that the output party will be `Party2`and the name of the output variable will be `my_output`. 
 
 # How to Run the Tutorial
 

examples/matrix_multiplication/README.md

@@ -8,11 +8,14 @@
 import py_nillion_client as nillion
 from dotenv import load_dotenv
 
-import nada_algebra.client as na_client
+import nada_numpy.client as na_client
+
 # Import helper functions for creating nillion client and getting keys
 from examples.common.nillion_client_helper import create_nillion_client
-from examples.common.nillion_keypath_helper import (getNodeKeyFromFile,
-                                                    getUserKeyFromFile)
+from examples.common.nillion_keypath_helper import (
+    getNodeKeyFromFile,
+    getUserKeyFromFile,
+)
 from examples.common.utils import compute, store_program, store_secrets
 from examples.matrix_multiplication.config import DIM
 

examples/matrix_multiplication/main.py

@@ -4,7 +4,8 @@
 
 from nada_dsl import Output, SecretInteger
 
-import nada_algebra as na
+# Step 0: Nada Numpy is imported with this line
+import nada_numpy as na
 
 
 def nada_main() -> List[Output]:
@@ -14,7 +15,7 @@ def nada_main() -> List[Output]:
     Returns:
         List[Output]: List of program outputs.
     """
-    # Step 1: We use Nada Algebra wrapper to create "Party0", "Party1" and "Party2"
+    # Step 1: We use Nada Numpy wrapper to create "Party0", "Party1" and "Party2"
     parties = na.parties(3)
 
     # Step 2: Party0 creates an array of dimension (3 x 3) with name "A"