rework files to pass pylint

Author: razvancrainea

opensips/__init__.py

@@ -17,5 +17,8 @@
 ## along with this program. If not, see <http://www.gnu.org/licenses/>.
 ##
 
-from .version import __version__
+""" Main package of OpenSIPS """
 
+from .mi import OpenSIPSMI
+from .event import OpenSIPSEvent
+from .version import __version__

opensips/event/__init__.py

@@ -17,4 +17,6 @@
 ## along with this program. If not, see <http://www.gnu.org/licenses/>.
 ##
 
+""" Event package of OpenSIPS """
+
 from .subscriber import OpenSIPSEvent, OpenSIPSEventException

opensips/event/datagram.py

@@ -17,40 +17,52 @@
 ## along with this program. If not, see <http://www.gnu.org/licenses/>.
 ##
 
+""" Implements Datagram Connection """
+
 import socket
 from .generic_socket import GenericSocket
 
 class Datagram(GenericSocket):
+
+    """ Datagram implementation of a socket """
+
     def __init__(self, **kwargs):
         self.ip = None
         self.port = None
+        self.sock = None
 
         if "unix_path" in kwargs:
             self.sock_name = kwargs["unix_path"]
         elif "ip" in kwargs and "port" in kwargs:
             self.ip = kwargs["ip"]
             self.port = int(kwargs["port"])
-            self.sock_name = f"udp:{self.ip}:{self.port}"
         else:
             raise ValueError("ip and port or unix_path is required for Datagram connector")
-    
+
     def create(self):
         if self.ip is not None:
             self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
             self.sock.bind((self.ip, self.port))
+            self.ip, self.port = self.sock.getsockname()
+            if self.ip == "0.0.0.0":
+                hostname = socket.gethostname()
+                self.ip = socket.gethostbyname(hostname)
+            self.sock_name = f"udp:{self.ip}:{self.port}"
         else:
             self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
             self.sock.bind(self.sock_name)
-        self.sock.setblocking(False)
+        # we are waiting blocking, so we don't have to change this
+        self.sock.settimeout(0.1)
+        return self.sock_name
 
-    def handle(self, callback, stop):
-        while not stop.is_set():
-            try:
-                data = self.sock.recv(1024)
-                callback(data)
-            except BlockingIOError:
-                pass
+    def read(self):
+        try:
+            return self.sock.recv(65535)
+        except socket.timeout:
+            return None
 
     def destroy(self):
+        if not self.sock:
+            return
         self.sock.close()
         self.sock = None

opensips/event/generic_socket.py

@@ -17,21 +17,26 @@
 ## along with this program. If not, see <http://www.gnu.org/licenses/>.
 ##
 
+""" Defines a generic socket """
+
 from abc import ABC, abstractmethod
 
 class GenericSocket(ABC):
+
+    """ Abstract class for a socket generic implementation """
+
     @abstractmethod
     def __init__(self, **kwargs):
         pass
 
     @abstractmethod
-    def create(self):
-        pass
+    def create(self) -> str:
+        """ Creates a socket """
 
     @abstractmethod
-    def handle(self, callback, stop):
-        pass
+    def read(self):
+        """ Reads data on the socket """
 
     @abstractmethod
     def destroy(self):
-        pass
+        """ Destroys the socket """

opensips/event/stream.py

@@ -17,39 +17,46 @@
 ## along with this program. If not, see <http://www.gnu.org/licenses/>.
 ##
 
+""" Implements TCP/Stream Connection """
+
 import socket
 from .generic_socket import GenericSocket
 
 class Stream(GenericSocket):
+
+    """ TCP/Stream implementation of a socket """
+
     def __init__(self, **kwargs):
         if "ip" not in kwargs:
             raise ValueError("ip is required for Stream connector")
         if "port" not in kwargs:
             raise ValueError("port is required for Stream connector")
-        
+
         self.ip = kwargs["ip"]
         self.port = int(kwargs["port"])
-        self.sock_name = f"tcp:{self.ip}:{self.port}"
+        self.sock = None
+        self.sock_name = None
 
     def create(self):
         self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         self.sock.bind((self.ip, self.port))
-        self.sock.setblocking(False)
+        self.ip, self.port = self.sock.getsockname()
+        if self.ip == "0.0.0.0":
+            hostname = socket.gethostname()
+            self.ip = socket.gethostbyname(hostname)
+        self.sock_name = f"udp:{self.ip}:{self.port}"
+        self.sock.settimeout(0.1)
         self.sock.listen(1)
+        return self.sock_name
+
+    def read(self):
+        try:
+            conn, _ = self.sock.accept()
+            with conn:
+                return conn.recv(65536)
+        except socket.timeout:
+            return None
 
-    def handle(self, callback, stop):
-        while not stop.is_set():
-            try:
-                conn, _ = self.sock.accept()
-                conn.setblocking(True)
-                with conn:
-                    data = conn.recv(1024)
-                    if not data:
-                        continue
-                    callback(data)
-            except BlockingIOError:
-                pass
-    
     def destroy(self):
         self.sock.close()
         self.sock = None

opensips/event/subscriber.py

@@ -17,60 +17,77 @@
 ## along with this program. If not, see <http://www.gnu.org/licenses/>.
 ##
 
+
+""" Module that implements OpenSIPS Event behavior """
+
+from threading import Thread, Event
 from ..mi import OpenSIPSMI, OpenSIPSMIException
 from .datagram import Datagram
 from .stream import Stream
-from threading import Thread, Event
 
 class OpenSIPSEventException(Exception):
-    pass
+    """ Exceptions generated by OpenSIPS Events """
 
 class OpenSIPSEvent():
-    def __init__(self, mi: OpenSIPSMI, type: str, **kwargs):
+
+    """ Implementation of the OpenSIPS Event """
+
+    def __init__(self, mi: OpenSIPSMI, _type: str, **kwargs):
         self.mi = mi
         self.kwargs = kwargs
+        self.thread = None
+        self.thread_stop = Event()
+        self.thread_stop.clear()
 
-        if type == "datagram":
+        if _type == "datagram":
             self.socket = Datagram(**kwargs)
-        elif type == "stream":
+        elif _type == "stream":
             self.socket = Stream(**kwargs)
         else:
             raise ValueError("Invalid event type")
 
+    def handle(self, callback):
+        """ Handles the event callbacks """
+        while not self.thread_stop.is_set():
+            data = self.socket.read()
+            if data:
+                callback(data)
+
     def subscribe(self, event: str, callback, expire=None):
+        """ Subscribes for an event """
         try:
+            sock_name = self.socket.create()
             if expire is None:
-                ret_val = self.mi.execute("event_subscribe", [event, self.socket.sock_name])
+                ret_val = self.mi.execute("event_subscribe", [event, sock_name])
             else:
-                ret_val = self.mi.execute("event_subscribe", [event, self.socket.sock_name, expire])
+                ret_val = self.mi.execute("event_subscribe", [event, sock_name, expire])
 
             if ret_val != "OK":
                 raise OpenSIPSEventException("Failed to subscribe to event")
-            
-            self.socket.create()
-            self.thread_stop = Event()
-            self.thread_stop.clear()
-            self.thread = Thread(target=self.socket.handle, args=(callback, self.thread_stop))
+
+            self.thread = Thread(target=self.handle, args=(callback,))
             self.thread.start()
 
         except OpenSIPSMIException as e:
             raise e
         except Exception as e:
-            raise OpenSIPSEventException("Failed to subscribe to event: {}".format(e))
-        
+            raise OpenSIPSEventException(f"Failed to subscribe to event: {e}") from e
+
     def unsubscribe(self, event: str):
+        """ Unsubscribes for an event """
         try:
             ret_val = self.mi.execute("event_subscribe", [event, self.socket.sock_name, 0])
 
             if ret_val != "OK":
                 raise OpenSIPSEventException("Failed to unsubscribe from event")
-            
+
             self.stop()
 
         except OpenSIPSMIException as e:
             raise e
 
     def stop(self):
+        """ Stops the current event processing """
         self.thread_stop.set()
         self.thread.join()
         self.socket.destroy()

opensips/mi/__init__.py

@@ -17,4 +17,7 @@
 ## along with this program. If not, see <http://www.gnu.org/licenses/>.
 ##
 
+
+""" OpenSIPS MI package """
+
 from .connector import OpenSIPSMI, OpenSIPSMIException

opensips/mi/connection.py

@@ -17,17 +17,23 @@
 ## along with this program. If not, see <http://www.gnu.org/licenses/>.
 ##
 
+
+""" Abstract implementation of an MI connection """
+
 from abc import ABC, abstractmethod
 
 class Connection(ABC):
+
+    """ Abstract MI Connection """
+
     @abstractmethod
     def __init__(self, **kwargs):
         pass
 
     @abstractmethod
     def execute(self, method: str, params: dict):
-        pass
+        """ Executes an MI Command """
 
     @abstractmethod
     def valid(self):
-        pass
+        """ Checks if an MI connection is valid """

opensips/mi/connector.py

@@ -17,15 +17,18 @@
 ## along with this program. If not, see <http://www.gnu.org/licenses/>.
 ##
 
+""" Connector implementation for OpenSIPS MI """
+
 from .fifo import FIFO
 from .datagram import Datagram
 from .http import HTTP
 from .jsonrpc_helper import JSONRPCError, JSONRPCException
 
 class OpenSIPSMIException(Exception):
-    pass
+    """ Generic OpenSIPS MI Exception """
 
 class OpenSIPSMI():
+    """ OpenSIPS MI Implementation """
     def __init__(self, conn="fifo", **kwargs):
         if conn == "fifo":
             if "fifo_file" not in kwargs:
@@ -43,17 +46,19 @@ def __init__(self, conn="fifo", **kwargs):
             raise ValueError("Invalid connector type")
 
         self.validated = None
-    
-    def execute(self, cmd, params=[]):
+
+    def execute(self, cmd, params=None):
+        """ Executes a command with the requested parameters """
         try:
-            ret_val = self.conn.execute(cmd, params)
+            ret_val = self.conn.execute(cmd, params if params else [])
         except JSONRPCError as e:
-            raise OpenSIPSMIException("Error executing command: {}".format(e))
+            raise OpenSIPSMIException(f"Error executing command: {e}") from e
         except JSONRPCException as e:
-            raise OpenSIPSMIException("Error with connection: {}. Is OpenSIPS running?".format(e))
+            raise OpenSIPSMIException(f"Error with connection: {e}. Is OpenSIPS running?") from e
         return ret_val
-    
+
     def valid(self):
+        """ Checks if the connector is valid """
         if self.validated is not None:
             return self.validated
         self.validated = self.conn.valid()

opensips/mi/datagram.py

@@ -17,18 +17,23 @@
 ## along with this program. If not, see <http://www.gnu.org/licenses/>.
 ##
 
+""" MI Datagram implementation """
+
+import socket
 from .connection import Connection
 from . import jsonrpc_helper
-import socket
 
 class Datagram(Connection):
+
+    """ MI Datagram connection """
+
     def __init__(self, **kwargs):
         if "datagram_ip" not in kwargs:
             raise ValueError("datagram_ip is required for Datagram connector")
-        
+
         if "datagram_port" not in kwargs:
             raise ValueError("datagram_port is required for Datagram connector")
-        
+
         self.ip = kwargs["datagram_ip"]
         self.port = int(kwargs["datagram_port"])
 
@@ -45,6 +50,6 @@ def execute(self, method: str, params: dict):
         finally:
             udp_socket.close()
         return jsonrpc_helper.get_reply(reply)
-    
+
     def valid(self):
         return (True, None)