naeural-client 2.0.0__py3-none-any.whl

naeural_client/base/responses.py

@@ -0,0 +1,209 @@
+from ..const.payload import NOTIFICATION_CODES, PAYLOAD_DATA
+
+
+class Response():
+  def __init__(self) -> None:
+    self.__is_solved = False
+    self.__is_good = None
+    self.__log = None
+
+    self.__fail_reason = None
+    return
+
+  def __repr__(self) -> str:
+    return f"<Response: {self.__class__.__name__}>"
+
+  def set_logger(self, log) -> None:
+    self.__log = log
+
+  def P(self, *args, **kwargs):
+    if self.__log is None:
+      print(*args, **kwargs)
+    self.__log.P(*args, **kwargs)
+
+  def D(self, *args, **kwargs):
+    if self.__log is None:
+      print(*args, **kwargs)
+    self.__log.D(*args, **kwargs)
+
+  def fail(self, fail_reason: str) -> None:
+    self.__is_solved = True
+    self.__is_good = False
+    self.__fail_reason = fail_reason
+    return
+
+  def success(self) -> None:
+    self.__is_good = True
+    self.__is_solved = True
+    return
+
+  def is_solved(self) -> bool:
+    return self.__is_solved
+
+  @property
+  def fail_reason(self) -> str:
+    return self.__fail_reason
+
+  def is_good_response(self) -> bool:
+    return self.__is_good
+
+  def handle_payload(self, payload: dict) -> None:
+    # Implement this method and call self.success() or self.fail(fail_reason) if expected message is received
+    return
+
+  def handle_notification(self, notification: dict) -> None:
+    # Implement this method and call self.success() or self.fail(fail_reason) if expected message is received
+    return
+
+  def handle_heartbeat(self, heartbeat) -> None:
+    # Implement this method and call self.success() or self.fail(fail_reason) if expected message is received
+    return
+
+
+class PipelineGenericNotificationResponse(Response):
+  def __init__(self, node, pipeline_name, success_code, fail_code) -> None:
+    super(PipelineGenericNotificationResponse, self).__init__()
+
+    self.node = node
+    self.pipeline_name = pipeline_name
+
+    self.success_code = success_code
+    self.fail_code = fail_code
+    return
+
+  def handle_notification(self, notification: dict) -> None:
+    if self.is_solved():
+      return
+
+    session_id = notification.get(PAYLOAD_DATA.SESSION_ID)
+    payload_path = notification.get(PAYLOAD_DATA.EE_PAYLOAD_PATH)
+    notification_code = notification.get("NOTIFICATION_CODE")  # TODO
+    notification_message = notification.get(PAYLOAD_DATA.NOTIFICATION)
+    node = payload_path[0]
+    pipeline = payload_path[1]
+
+    # ignore session_id for now, until we decide on the behavior of the EE
+    same_node = node == self.node
+    same_pipeline = pipeline == self.pipeline_name
+    notification_code_ok = notification_code == self.success_code
+    notification_code_failed = notification_code == self.fail_code
+
+    if same_node and same_pipeline:
+      self.D("Received notification CODE={} for <{}: {}>. Message: {}".format(
+        notification_code, node, pipeline, notification_message))
+      if notification_code_ok:
+        self.success()
+      elif notification_code_failed:
+        self.fail(notification_message)
+    return
+
+
+class InstanceGenericNotificationResponse(Response):
+  def __init__(self, node, pipeline_name, signature, instance_id, success_code, fail_code) -> None:
+    super(InstanceGenericNotificationResponse, self).__init__()
+
+    self.node = node
+    self.pipeline_name = pipeline_name
+    if signature is not None:
+      self.signature = signature.upper()
+    self.instance_id = instance_id
+
+    self.success_code = success_code
+    self.fail_code = fail_code
+
+    return
+
+  def handle_notification(self, notification: dict) -> None:
+    if self.is_solved():
+      return
+
+    session_id = notification.get(PAYLOAD_DATA.SESSION_ID)
+    payload_path = notification.get(PAYLOAD_DATA.EE_PAYLOAD_PATH)
+    notification_code = notification.get("NOTIFICATION_CODE")  # TODO
+    notification_message = notification.get(PAYLOAD_DATA.NOTIFICATION)
+    notification_info = notification.get(PAYLOAD_DATA.INFO)
+    node = payload_path[0]
+    pipeline = payload_path[1]
+    signature = payload_path[2]
+    if signature is not None:
+      signature = signature.upper()
+    instance_id = payload_path[3]
+
+    # ignore session_id for now, until we decide on the behavior of the EE
+    same_node = node == self.node
+    same_pipeline = pipeline == self.pipeline_name
+    same_signature = signature == self.signature
+    same_instance_id = instance_id == self.instance_id
+    notification_code_ok = notification_code == self.success_code
+    notification_code_failed = notification_code == self.fail_code
+
+    if same_node and same_pipeline and same_signature and same_instance_id:
+      self.D("Received notification CODE={} for <{}: {}/{}/{}>. Message: {}\nInfo: {}".format(
+        notification_code, node, pipeline, signature, instance_id,
+        notification_message, notification_info))
+      if notification_code_ok:
+        self.success()
+      elif notification_code_failed:
+        self.fail(notification_info)
+    return
+
+
+class PipelineOKResponse(PipelineGenericNotificationResponse):
+  def __init__(self, node, pipeline_name) -> None:
+    super(PipelineOKResponse, self).__init__(
+      node=node,
+      pipeline_name=pipeline_name,
+      success_code=NOTIFICATION_CODES.PIPELINE_OK,
+      fail_code=NOTIFICATION_CODES.PIPELINE_FAILED
+    )
+    return
+
+
+class PipelineArchiveResponse(PipelineGenericNotificationResponse):
+  def __init__(self, node, pipeline_name) -> None:
+    super(PipelineArchiveResponse, self).__init__(
+      node=node,
+      pipeline_name=pipeline_name,
+      success_code=NOTIFICATION_CODES.PIPELINE_ARCHIVE_OK,
+      fail_code=NOTIFICATION_CODES.PIPELINE_ARCHIVE_FAILED
+    )
+    return
+
+
+class PluginConfigInPauseOKResponse(InstanceGenericNotificationResponse):
+  def __init__(self, node, pipeline_name, signature, instance_id) -> None:
+    super(PluginConfigInPauseOKResponse, self).__init__(
+      node=node,
+      pipeline_name=pipeline_name,
+      signature=signature,
+      instance_id=instance_id,
+      success_code=NOTIFICATION_CODES.PLUGIN_CONFIG_IN_PAUSE_OK,
+      fail_code=NOTIFICATION_CODES.PLUGIN_CONFIG_IN_PAUSE_FAILED
+    )
+    return
+
+
+class PluginConfigOKResponse(InstanceGenericNotificationResponse):
+  def __init__(self, node, pipeline_name, signature, instance_id) -> None:
+    super(PluginConfigOKResponse, self).__init__(
+      node=node,
+      pipeline_name=pipeline_name,
+      signature=signature,
+      instance_id=instance_id,
+      success_code=NOTIFICATION_CODES.PLUGIN_CONFIG_OK,
+      fail_code=NOTIFICATION_CODES.PLUGIN_CONFIG_FAILED
+    )
+    return
+
+
+class PluginInstanceCommandOKResponse(InstanceGenericNotificationResponse):
+  def __init__(self, node, pipeline_name, signature, instance_id) -> None:
+    super(PluginInstanceCommandOKResponse, self).__init__(
+      node=node,
+      pipeline_name=pipeline_name,
+      signature=signature,
+      instance_id=instance_id,
+      success_code=NOTIFICATION_CODES.PLUGIN_INSTANCE_COMMAND_OK,
+      fail_code=NOTIFICATION_CODES.PLUGIN_INSTANCE_COMMAND_FAILED
+    )
+    return

naeural_client/base/transaction.py

@@ -0,0 +1,157 @@
+from PyE2.base.responses import Response
+# from .responses import Response
+from time import time, sleep
+
+
+class Transaction():
+  def __init__(self, log, session_id: str, *, lst_required_responses: list[Response] = None, timeout: int = 0, on_success_callback: callable = None, on_failure_callback: callable = None) -> None:
+    self.log = log
+    self.session_id = session_id
+    self.lst_required_responses = lst_required_responses
+    self.timeout = timeout
+
+    self.on_success_callback = on_success_callback
+    self.on_failure_callback = on_failure_callback
+
+    self.resolved_callback = None
+    self.__is_solved = False
+    self.__is_finished = False
+
+    self.start_time = time()
+    for response in self.lst_required_responses:
+      response.set_logger(log)
+
+    return
+
+  def get_unsolved_responses(self) -> list[Response]:
+    """
+    Returns a list of unsolved responses in the transaction.
+
+    Returns
+    -------
+    list[Response]
+        List of unsolved responses in the transaction.
+    """
+    return [response for response in self.lst_required_responses if not response.is_solved()]
+
+  def is_solved(self) -> bool:
+    """
+    Returns whether the transaction is solved or not.
+    If the transaction is solved in this call, the resolved_callback is set to the appropriate callback function.
+
+    Returns
+    -------
+    bool
+        Whether the transaction is solved or not.
+    """
+
+    # if the transaction is already solved, return True
+    if self.__is_solved:
+      return True
+
+    # first check if all responses are solved
+    all_responses_solved = all([response.is_solved() for response in self.lst_required_responses])
+    if all_responses_solved:
+      self.__is_solved = True
+
+      all_responses_good = all([response.is_good_response() for response in self.lst_required_responses])
+      if all_responses_good:
+        self.resolved_callback = self.on_success_callback
+      else:
+        if not self.on_failure_callback:
+          self.resolved_callback = lambda: self.log.P("Transaction failed")
+        else:
+          fail_reasons = [
+            response.fail_reason for response in self.lst_required_responses if not response.is_good_response()]
+          self.resolved_callback = lambda: self.on_failure_callback(fail_reasons)
+        # endif computing resolved_callback for failure
+      # endif computing resolved_callback
+      return True
+    # endif all responses solved
+
+    # if the transaction is not solved, check if the transaction has timed out
+    elapsed_time = time() - self.start_time
+    if self.timeout > 0 and elapsed_time > self.timeout:
+      # Timeout occurred
+      self.__is_solved = True
+
+      fail_reason = f"Transaction timeout ({self.timeout}s). Responses not received: "
+      fail_reason += ", ".join([str(response) for response in self.lst_required_responses if not response.is_solved()])
+
+      if not self.on_failure_callback:
+        self.resolved_callback = lambda: self.log.P(fail_reason)
+      else:
+        self.resolved_callback = lambda: self.on_failure_callback([fail_reason])
+      return True
+
+    return False
+
+  def is_finished(self) -> bool:
+    """
+    Returns whether the transaction is finished or not.
+    A transaction finishes when the callback is called.
+
+    Returns
+    -------
+    bool
+        Whether the transaction is finished or not.
+    """
+    return self.__is_finished
+
+  def handle_payload(self, payload: dict) -> None:
+    """
+    This method is called when a payload is received from the server.
+    This method calls `handle_payload()` method of all the unsolved responses in the `lst_required_responses`.
+
+    Parameters
+    ----------
+    payload : dict
+        The payload received from the server.
+    """
+    unsolved_responses = self.get_unsolved_responses()
+
+    for response in unsolved_responses:
+      response.handle_payload(payload)
+    return
+
+  def handle_notification(self, notification: dict) -> None:
+    """
+    This method is called when a notification is received from the server.
+    This method calls `handle_notification()` method of all the unsolved responses in the `lst_required_responses`.
+
+    Parameters
+    ----------
+    notification : dict
+        The notification received from the server.
+    """
+    unsolved_responses = self.get_unsolved_responses()
+
+    for response in unsolved_responses:
+      response.handle_notification(notification)
+    return
+
+  def handle_heartbeat(self, heartbeat) -> None:
+    """
+    This method is called when a heartbeat is received from the server.
+    This method calls `handle_heartbeat()` method of all the unsolved responses in the `lst_required_responses`.
+
+    Parameters
+    ----------
+    heartbeat : dict
+        The heartbeat received from the server.
+    """
+    unsolved_responses = self.get_unsolved_responses()
+
+    for response in unsolved_responses:
+      response.handle_heartbeat(heartbeat)
+    return
+
+  def callback(self):
+    """
+    Calls the resolved_callback only if the transaction is solved.
+    """
+    if self.__is_solved:
+      if self.resolved_callback:
+        self.resolved_callback()
+      self.__is_finished = True
+    return

naeural_client/base_decentra_object.py

@@ -0,0 +1,143 @@
+from .logging import Logger
+
+
+class BaseDecentrAIObject(object):
+  """
+  Generic class
+
+  Instructions:
+
+    1. use `super().__init__(**kwargs)` at the end of child `__init__`
+    2. define `startup(self)` method for the child class and call 
+       `super().startup()` at beginning of `startup()` method
+
+      OR
+
+    use `super().__init__(**kwargs)` at beginning of child `__init__` and then
+    you can safely proceed with other initilization 
+
+  """
+
+  def __init__(self, log: Logger,
+               create_logger=False,
+               DEBUG=False,
+               show_prefixes=False,
+               prefix_log=None,
+               log_at_startup=False,
+               **kwargs):
+
+    super(BaseDecentrAIObject, self).__init__()
+
+    if (log is None) or not hasattr(log, '_logger'):
+      if not create_logger:
+        raise ValueError("Logger object is invalid: {}".format(log))
+      else:
+        log = Logger(DEBUG=DEBUG, base_folder='.', app_folder='_local_cache')
+    # endif
+
+    self.log = log
+    self.show_prefixes = show_prefixes
+    self.prefix_log = prefix_log
+    self.config_data = self.log.config_data
+    self.DEBUG = DEBUG
+    self.log_at_startup = log_at_startup
+
+    if not hasattr(self, '__name__'):
+      self.__name__ = self.__class__.__name__
+    self.startup()
+
+    return
+
+  def startup(self):
+    self.log.set_nice_prints()
+    ver = ''
+    if hasattr(self, '__version__'):
+      ver = 'v.' + self.__version__
+    if hasattr(self, 'version'):
+      ver = 'v.' + self.version
+
+    if self.log_at_startup:
+      self.P("{}{} startup.".format(self.__class__.__name__, ' ' + ver if ver != '' else ''))
+    return
+
+  def shutdown(self):
+    self.P("Shutdown in progress...")
+    _VARS = ['sess', 'session']
+    for var_name in _VARS:
+      if vars(self).get(var_name, None) is not None:
+        self.P("Warning: {} property {} still not none before closing".format(
+          self.__class__.__name__, var_name), color='r')
+    return
+
+  def P(self, s, t=False, color=None, prefix=False, **kwargs):
+    if self.show_prefixes or prefix:
+      msg = "[{}] {}".format(self.__name__, s)
+    else:
+      if self.prefix_log is None:
+        msg = "{}".format(s)
+      else:
+        msg = "{} {}".format(self.prefix_log, s)
+      # endif
+    # endif
+
+    _r = self.log.P(msg, show_time=t, color=color, **kwargs)
+    return _r
+
+  def D(self, s, t=False, color=None, prefix=False, **kwargs):
+    _r = -1
+    if self.DEBUG:
+      if self.show_prefixes:
+        msg = "[DEBUG] {}: {}".format(self.__name__, s)
+      else:
+        if self.prefix_log is None:
+          msg = "[DEBUG] {}".format(s)
+        else:
+          msg = "[DEBUG]{} {}".format(self.prefix_log, s)
+        # endif
+      # endif
+      _r = self.log.P(msg, show_time=t, color=color, prefix=prefix, **kwargs)
+    # endif
+    return _r
+
+  def start_timer(self, tmr_id):
+    if hasattr(self, '_timers_section'):
+      return self.log.start_timer(tmr_id, section=self._timers_section)
+    else:
+      return self.log.start_timer(sname=self.__name__ + '_' + tmr_id)
+
+  def end_timer(self, tmr_id, skip_first_timing=True, **kwargs):
+    if hasattr(self, '_timers_section'):
+      return self.log.end_timer(tmr_id, section=self._timers_section)
+    else:
+      return self.log.end_timer(
+        sname=self.__name__ + '_' + tmr_id,
+        skip_first_timing=skip_first_timing,
+        **kwargs
+      )
+
+  def raise_error(self, error_text):
+    """
+    logs the error and raises it
+    """
+    self.P("{}: {}".format(self.__class__.__name__, error_text))
+    raise ValueError(error_text)
+
+  def timer_name(self, name=''):
+    tn = ''
+    if name == '':
+      tn = self.__class__.__name__
+    else:
+      tn = '{}__{}'.format(self.__class__.__name__, name)
+    return tn
+
+  def __repr__(self):
+    # Get the name of the class
+    class_name = self.__class__.__name__
+
+    # Get public properties (those not starting with "_")
+    public_properties = {k: v for k, v in self.__dict__.items() if not k.startswith("_")}
+
+    # Convert properties to a string representation
+    properties_str = ", ".join(f"{k}={v!r}" for k, v in public_properties.items())
+
+    return f"{class_name}({properties_str})"

naeural_client/bc/__init__.py

@@ -0,0 +1,3 @@
+from .ec import BaseBCEllipticCurveEngine
+from .base import BCct, _DotDict, _ComplexJsonEncoder, VerifyMessage
+DefaultBlockEngine = BaseBCEllipticCurveEngine