Fix/minor naming feedback (#129)

* add ability to import `PymiloClient`, `PymiloServer` and `Compression` directly from `streaming` package

* convert Mode to an inner class + update non-private field attributes naming convention

* update non-private field attributes naming convention

* refactor testcases based on applied updates

Author: AHReccese

pymilo/streaming/__init__.py

@@ -1,2 +1,5 @@
 # -*- coding: utf-8 -*-
 """PyMilo ML Streaming."""
+from .pymilo_client import PymiloClient
+from .pymilo_server import PymiloServer
+from .compressor import Compression

pymilo/streaming/pymilo_client.py

@@ -11,16 +11,15 @@
 from ..transporters.general_data_structure_transporter import GeneralDataStructureTransporter
 
 
-class Mode(Enum):
-    """fallback state of the PyMiloClient."""
-
-    LOCAL = 1
-    DELEGATE = 2
-
-
 class PymiloClient:
     """Facilitate working with the PyMilo server."""
 
+    class Mode(Enum):
+        """fallback state of the PyMiloClient."""
+
+        LOCAL = 1
+        DELEGATE = 2
+
     def __init__(
             self,
             model=None,
@@ -41,9 +40,9 @@ def __init__(
         :type server_url: str
         :return: an instance of the Pymilo PymiloClient class
         """
-        self._client_id = "0x_client_id"
-        self._model_id = "0x_model_id"
-        self._model = model
+        self.model = model
+        self.client_id = "0x_client_id"
+        self.model_id = "0x_model_id"
         self._mode = mode
         self._compressor = compressor.value
         self._encryptor = DummyEncryptor()
@@ -69,7 +68,7 @@ def toggle_mode(self, mode=Mode.LOCAL):
 
         :return: None
         """
-        if mode not in Mode.__members__.values():
+        if mode not in PymiloClient.Mode.__members__.values():
             raise Exception(PYMILO_CLIENT_INVALID_MODE)
         if mode != self._mode:
             self._mode = mode
@@ -83,15 +82,15 @@ def download(self):
         serialized_model = self._communicator.download(
             self.encrypt_compress(
                 {
-                    "client_id": self._client_id,
-                    "model_id": self._model_id,
+                    "client_id": self.client_id,
+                    "model_id": self.model_id,
                 }
             )
         )
         if serialized_model is None:
             print(PYMILO_CLIENT_FAILED_TO_DOWNLOAD_REMOTE_MODEL)
             return
-        self._model = Import(file_adr=None, json_dump=serialized_model).to_model()
+        self.model = Import(file_adr=None, json_dump=serialized_model).to_model()
         print(PYMILO_CLIENT_MODEL_SYNCHED)
 
     def upload(self):
@@ -103,9 +102,9 @@ def upload(self):
         succeed = self._communicator.upload(
             self.encrypt_compress(
                 {
-                    "client_id": self._client_id,
-                    "model_id": self._model_id,
-                    "model": Export(self._model).to_json(),
+                    "client_id": self.client_id,
+                    "model_id": self.model_id,
+                    "model": Export(self.model).to_json(),
                 }
             )
         )
@@ -123,18 +122,18 @@ def __getattr__(self, attribute):
 
         :return: Any
         """
-        if self._mode == Mode.LOCAL:
-            if attribute in dir(self._model):
-                return getattr(self._model, attribute)
+        if self._mode == PymiloClient.Mode.LOCAL:
+            if attribute in dir(self.model):
+                return getattr(self.model, attribute)
             else:
                 raise AttributeError(PYMILO_CLIENT_INVALID_ATTRIBUTE)
-        elif self._mode == Mode.DELEGATE:
+        elif self._mode == PymiloClient.Mode.DELEGATE:
             gdst = GeneralDataStructureTransporter()
             response = self._communicator.attribute_type(
                 self.encrypt_compress(
                     {
-                        "client_id": self._client_id,
-                        "model_id": self._model_id,
+                        "client_id": self.client_id,
+                        "model_id": self.model_id,
                         "attribute": attribute,
                     }
                 )
@@ -144,8 +143,8 @@ def __getattr__(self, attribute):
 
             def relayer(*args, **kwargs):
                 payload = {
-                    "client_id": self._client_id,
-                    "model_id": self._model_id,
+                    "client_id": self.client_id,
+                    "model_id": self.model_id,
                     'attribute': attribute,
                     'args': args,
                     'kwargs': kwargs,

pymilo/streaming/pymilo_server.py

@@ -24,7 +24,7 @@ def __init__(self, port=8000, compressor=Compression.NULL):
         self._model = None
         self._compressor = compressor.value
         self._encryptor = DummyEncryptor()
-        self._communicator = RESTServerCommunicator(ps=self, port=port)
+        self.communicator = RESTServerCommunicator(ps=self, port=port)
 
     def export_model(self):
         """

tests/test_ml_streaming/run_server.py

@@ -1,14 +1,14 @@
 import argparse
-from pymilo.streaming.compressor import Compression
-from pymilo.streaming.pymilo_server import PymiloServer
+from pymilo.streaming import Compression
+from pymilo.streaming import PymiloServer
 
 
 def main():
     parser = argparse.ArgumentParser(description='Run the Pymilo server with a specified compression method.')
     parser.add_argument('--compression', type=str, choices=['NULL', 'GZIP', 'ZLIB', 'LZMA', 'BZ2'], default='NULL',
                         help='Specify the compression method (NULL, GZIP, ZLIB, LZMA, or BZ2). Default is NULL.')
     args = parser.parse_args()
-    communicator = PymiloServer(compressor=Compression[args.compression])._communicator
+    communicator = PymiloServer(compressor=Compression[args.compression]).communicator
     communicator.run()
 
 if __name__ == '__main__':

tests/test_ml_streaming/scenarios/scenario1.py

@@ -1,8 +1,8 @@
 import numpy as np
+from pymilo.streaming import Compression
+from pymilo.streaming import PymiloClient
 from sklearn.metrics import mean_squared_error
 from sklearn.linear_model import LinearRegression
-from pymilo.streaming.compressor import Compression
-from pymilo.streaming.pymilo_client import PymiloClient, Mode
 from pymilo.utils.data_exporter import prepare_simple_regression_datasets
 
 
@@ -21,7 +21,7 @@ def scenario1(compression_method):
 
     # 2.
     linear_regression.fit(x_train, y_train)
-    client = PymiloClient(model=linear_regression, mode=Mode.LOCAL, compressor=Compression[compression_method])
+    client = PymiloClient(model=linear_regression, mode=PymiloClient.Mode.LOCAL, compressor=Compression[compression_method])
 
     # 3.
     result = client.predict(x_test)

tests/test_ml_streaming/scenarios/scenario2.py

@@ -1,8 +1,8 @@
 import numpy as np
+from pymilo.streaming import Compression
+from pymilo.streaming import PymiloClient
 from sklearn.metrics import mean_squared_error
 from sklearn.linear_model import LinearRegression
-from pymilo.streaming.compressor import Compression
-from pymilo.streaming.pymilo_client import PymiloClient, Mode
 from pymilo.utils.data_exporter import prepare_simple_regression_datasets
 
 
@@ -18,13 +18,13 @@ def scenario2(compression_method):
     # 1.
     x_train, y_train, x_test, y_test = prepare_simple_regression_datasets()
     linear_regression = LinearRegression()
-    client = PymiloClient(model=linear_regression, mode=Mode.LOCAL, compressor=Compression[compression_method])
+    client = PymiloClient(model=linear_regression, mode=PymiloClient.Mode.LOCAL, compressor=Compression[compression_method])
 
     # 2.
     client.upload()
 
     # 3.
-    client.toggle_mode(Mode.DELEGATE)
+    client.toggle_mode(PymiloClient.Mode.DELEGATE)
     client.fit(x_train, y_train)
     remote_field = client.coef_
 
@@ -36,7 +36,7 @@ def scenario2(compression_method):
     client.download()
 
     # 6.
-    client.toggle_mode(mode=Mode.LOCAL)
+    client.toggle_mode(mode=PymiloClient.Mode.LOCAL)
     local_field = client.coef_
     result = client.predict(x_test)
     mse_local = mean_squared_error(y_test, result)