PyPI - p3lib - Versions diffs - 1.1.108__py2.py3-none-any.whl - Mend

p3lib 1.1.108__py2.py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (24) hide show

p3lib/login.html ADDED Viewed

@@ -0,0 +1,98 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Bokeh App with Login</title>
+    <style>
+    *{
+        margin:0;
+        padding: 0;
+        box-sizing: border-box;
+    }
+    html{
+        height: 100%;
+    }
+    body{
+        font-family: 'Segoe UI', sans-serif;;
+        font-size: 1rem;
+        line-height: 1.6;
+        height: 100%;
+    }
+    p{
+        padding-bottom: 5px;
+    }
+    .wrap {
+        width: 100%;
+        height: 100%;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        background: #fafafa;
+    }
+    .login-form{
+        width: 350px;
+        margin: 0 auto;
+        border: 1px solid #ddd;
+        padding: 2rem;
+        background: #ffffff;
+    }
+    .form-input{
+        background: #fafafa;
+        border: 1px solid #eeeeee;
+        padding: 12px;
+        width: 100%;
+    }
+    .form-group{
+        margin-bottom: 1rem;
+    }
+    .form-button{
+        background: #69d2e7;
+        border: 1px solid #ddd;
+        color: #ffffff;
+        padding: 10px;
+        width: 100%;
+        text-transform: uppercase;
+    }
+    .form-button:hover{
+        background: #69c8e7;
+    }
+    .form-header{
+        text-align: center;
+        margin-bottom : 2rem;
+    }
+    .form-footer{
+        text-align: center;
+    }
+    </style>
+</head>
+<body>
+    <div class="wrap">
+        <form class="login-form" action="/login" method="post">
+            {% module xsrf_form_html() %}
+            <div class="form-header">
+                <h3><img src="https://static.bokeh.org/logos/logotype.svg"></h3>
+                <p> Login to access your application</p>
+            </div>
+            <!--Email Input-->
+            <div class="form-group">
+                <input name="username" type="text" class="form-input" autocapitalize="off" autocorrect="off" placeholder="username">
+            </div>
+            <!--Password Input-->
+            <div class="form-group">
+                <input name="password" type="password" class="form-input" placeholder="password">
+            </div>
+            <!--Login Button-->
+            <div class="form-group">
+                <button class="form-button" type="submit">Login</button>
+            </div>
+            <span class="errormessage">{{errormessage}}</span>
+            <div><small>
+            <p>This is a <b>toy example</b> that demonstrates the authentication building blocks that are available with a Bokeh server.</p>
+            <p>You can log in with user: <b><i>bokeh</i></b> / pass: <b><i>bokeh</i></b></p>
+            <p><a href="https://docs.bokeh.org/en/latest/docs/user_guide/server/deploy.html#authentication">See the documentation</a> for a full discussion.</p>
+            </small></div>
+        </form>
+    </div>
+</body>
+</html>

p3lib/mqtt_rpc.py ADDED Viewed

@@ -0,0 +1,240 @@
+#!/usr/bin/python3
+import  paho.mqtt.client as mqtt
+from    abc import abstractmethod
+import  json
+import  traceback
+from    threading import Condition
+from    queue import Queue
+class MQTTError(Exception):
+  pass
+class MQTTRPCClient(object):
+    DEFAULT_HOST                = "localhost"
+    DEFAULT_PORT                = 1883
+    DEFAULT_KEEPALIVE_SECONDS   = 60
+    DEFAULT_SRV_ID              = 1
+    CLIENT_ID_DICT_KEY          = "SRC"
+    METHOD_DICT_KEY             = "METHOD"
+    ARGS_DICT_KEY               = "ARGS"
+    RESPONSE_DICT_KEY           = "RESPONSE"
+    @staticmethod
+    def GetServerRPCTopic(idNumber=1):
+        """@brief Responsible for getting the Server RPC topic string.
+           @param idNumber The idNumber of the RPC server that RPC messages can be sent to.
+           @return A string that represents the RPC server topic."""
+        return "server%d/RPC" % (idNumber)
+    @staticmethod
+    def GetClientID(id=1):
+        """@brief Responsible for getting a client ID string.
+           @param id The unique id of the MQTT client.
+           @return A string that represents the unique client ID."""
+        return "client%s/RPC" % ( str(id) )
+    def __init__(self, uo, options):
+        """@brief Responsible fopr providing RPC functionality via an MQTT server.
+           @param uo A UO instance that implements the info(text) and error(text) methods
+                       to send information to the user.
+           @param options An options instance.
+                    options.sid = A number to uniquely identify the server
+                    options.cid = A number to uniquely identify the client
+                    options.server = The host address of the MQTT server
+                    options.port = The port number to connect to the MQTT server
+                    options.keepalive = The keepalive period in seconds
+           The MQTTRPCClient class can only be a base class and should be extended. Child classes must
+           implement/override the _onMessage() method."""
+        self._uo = uo
+        self._options = options
+        self._serverRPCTopic = MQTTRPCClient.GetServerRPCTopic(idNumber=self._options.sid)
+        self._client = mqtt.Client()
+        self._client.on_connect = self._onConnect
+        self._client.on_message = self._onMessage
+    def connect(self):
+        """@brief Connect to the MQTT server"""
+        self._client.connect(self._options.server, self._options.port, self._options.keepalive)
+    def loopForever(self):
+        """@brief Wait here to service messages after a successfll connection."""
+        self._client.loop_forever()
+    def _onConnect(self, client, userdata, flags, rc):
+        """@brief Called when connected to the MQTT server."""
+        self._client.subscribe( self._serverRPCTopic )
+        self._uo.info("Connected to MQTT server (%s:%d) and subscribed to %s" % (self._options.server, self._options.port, self._serverRPCTopic) )
+    @abstractmethod
+    def _onMessage(self, client, userdata, msg):
+        """@brief Called when a message is received from the MQTT server.
+                  This method mst be implented in a child class."""
+        pass
+class MQTTRPCProviderClient(MQTTRPCClient):
+    def __init__(self, uo, options, rpcMethodProviderList):
+        """@brief Responsible for providing RPC functionality via an MQTT server.
+                  MQTTRPCProviderClient instances implement the RPC at the destination/remote side
+                  and return the results to the caller side.
+           @param uo A UO instance that implements the info(text) and error(text) methods
+                     to send information to the user.
+           @param options An options instance.
+                    options.sid = A number to uniquely identify the server
+                    options.cid = A number to uniquely identify the client receiving responses from the server.
+                    options.server = The host address of the MQTT server
+                    options.port = The port number to connect to the MQTT server
+                    options.keepalive = The keepalive period in seconds
+           @param rpcMethodProviderList A list/tuple of class instances that provide the RPC methods."""
+        MQTTRPCClient.__init__(self, uo, options)
+        self._rpcMethodProviderList=rpcMethodProviderList
+    def _onMessage(self, client, userdata, msg):
+        """@brief Called when a message is received from the MQTT server.
+           @param client:     the client instance for this callback
+           @param userdata:   the private user data as set in Client() or userdata_set()
+           @param message:    an instance of MQTTMessage.
+                              This is a class with members topic, payload, qos, retain."""
+        try:
+          rxStr = msg.payload.decode()
+          self._uo.info( "RX: %s" % (rxStr) )
+          jsonDict = json.loads( msg.payload.decode() )
+          if MQTTRPCClient.CLIENT_ID_DICT_KEY in jsonDict and MQTTRPCClient.METHOD_DICT_KEY in jsonDict:
+              clientID = jsonDict[MQTTRPCClient.CLIENT_ID_DICT_KEY]
+              methodName = jsonDict[MQTTRPCClient.METHOD_DICT_KEY]
+              args = jsonDict[MQTTRPCClient.ARGS_DICT_KEY]
+              method = None
+              for rpcMethodProvider in self._rpcMethodProviderList:
+                  if hasattr(rpcMethodProvider, methodName):
+                      method = getattr(rpcMethodProvider, methodName)
+              if method:
+                  if len(args) > 0:
+                      response = method(args)
+                  else:
+                      response = method()
+                  jsonDict[MQTTRPCClient.RESPONSE_DICT_KEY]=response
+                  jsonString = json.dumps(jsonDict)
+                  self._uo.info( "TX: %s" % (jsonString) )
+                  client.publish(clientID, jsonString)
+              else:
+                  raise AttributeError("Unable to find a provider of the %s method." % (methodName) )
+        except:
+            tb = traceback.format_exc()
+            self._uo.error(tb)
+class MQTTRPCCallerClient(MQTTRPCClient):
+    def __init__(self, uo, options, responseTimeoutSeconds = 10):
+        """@brief Responsible fopr providing RPC functionality via an MQTT server.
+                  MQTTRPCCallerClient instances implement the RPC at the src/caller side
+                  sending RPC requests to destination/remote and reciving responses.
+           @param uo A UO instance that implements the info(text) and error(text) methods
+                     to send information to the user.
+           @param options An options instance.
+                    options.sid = A number to uniquely identify the server responding to RPC calls.
+                    options.cid = A number to uniquely identify the client receiving responses from the server.
+                    options.server = The host address of the MQTT server
+                    options.port = The port number to connect to the MQTT server
+                    options.keepalive = The keepalive period in seconds
+           @param timeoutSeconds The number of seconds to wait for a timeout when no response is received."""
+        MQTTRPCClient.__init__(self, uo, options)
+        self._responseTimeoutSeconds = responseTimeoutSeconds
+        self._clientSRC = MQTTRPCClient.GetClientID(options.cid)
+        self._serverRPCTopic = MQTTRPCClient.GetServerRPCTopic(idNumber=self._options.sid)
+        self._sendMsgDict = None
+        self._responseQueue = Queue()
+        self._condition = Condition()
+    def _onMessage(self, client, userdata, msg):
+        """@brief Called when a message is received from the MQTT server.
+           @param client:     the client instance for this callback
+           @param userdata:   the private user data as set in Client() or userdata_set()
+           @param message:    an instance of MQTTMessage.
+                              This is a class with members topic, payload, qos, retain.
+           @return None"""
+        try:
+          responseDict = json.loads( msg.payload.decode() )
+          if responseDict and MQTTRPCClient.RESPONSE_DICT_KEY in responseDict:
+              self._condition.acquire()
+              self._responseQueue.put(responseDict[MQTTRPCClient.RESPONSE_DICT_KEY])
+              self._condition.notify()
+              self._condition.release()
+        except:
+            tb = traceback.format_exc()
+            self._uo.error(tb)
+    def _getResponse(self):
+        """@brief Internal method used to get the response to an RPC
+           @return The response to the RPC or None if a timeout occurs."""
+        # blocks until the response is processed or a timeout occurs
+        self._condition.wait(timeout=self._responseTimeoutSeconds)
+        response = None
+        if not self._responseQueue.empty():
+            response = self._responseQueue.get()
+        return response
+    def _getRPCString(self):
+        """@brief Get the last RPC called as a string.
+           @return The RPC string representation."""
+        if self._sendMsgDict and MQTTRPCClient.METHOD_DICT_KEY in self._sendMsgDict and MQTTRPCClient.ARGS_DICT_KEY in self._sendMsgDict:
+            return "%s(%s)" % (self._sendMsgDict[MQTTRPCClient.METHOD_DICT_KEY], self._sendMsgDict[MQTTRPCClient.ARGS_DICT_KEY])
+        else:
+            return ""
+    def rpcCall(self, methodName, argList):
+        """@brief Call an RPC
+           @param methodName The name of the RPC to call. Currently this is just the method name.
+                             This method could exist on an instance of any object. We could have
+                             made this include instance details but to keep things simple
+                             just the method name is provided.
+           @param argList The arguments for the RPC
+           @return The response to the RPC."""
+        self._sendMsgDict={}
+        self._sendMsgDict[MQTTRPCClient.CLIENT_ID_DICT_KEY]=self._clientSRC
+        self._sendMsgDict[MQTTRPCClient.METHOD_DICT_KEY]=methodName
+        self._sendMsgDict[MQTTRPCClient.ARGS_DICT_KEY]=argList
+        jsonDict = json.dumps(self._sendMsgDict, indent=4, sort_keys=True)
+        self._client.subscribe(self._clientSRC)
+        self._condition.acquire()
+        response = None
+        try:
+            self._client.publish(self._serverRPCTopic, jsonDict)
+            response = self._getResponse()
+        finally:
+            self._condition.release()
+        return response

p3lib/netif.py ADDED Viewed

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3.8
+import  platform
+from    subprocess import check_output
+import  socket
+import  struct
+class NetIF(object):
+    """@Responsible for determining details about the network interfaces on a PC."""
+    LINUX_OS_NAME      = "Linux"
+    SUPPORTED_OS_NAMES = [ LINUX_OS_NAME ]
+    ID_STR1            = "inet addr:"
+    ID_STR2            = "addr:"
+    ID_STR3            = "mask:"
+    ID_STR4            = "inet "
+    IP_NETMASK_SEP     = "/"
+    @staticmethod
+    def IsAddressInNetwork(ip, net):
+        """@brief Determine if an IP address is in a IP network.
+           @param ip The IP address of the interface in the format 192.168.1.20
+           @param net The network in the format 192.168.1.0/24"""
+        ipaddr = socket.inet_aton(ip)
+        netaddr, netmask = net.split(NetIF.IP_NETMASK_SEP)
+        netaddr = socket.inet_aton(netaddr)
+        ipint = struct.unpack("!I", ipaddr)[0]
+        netint = struct.unpack("!I", netaddr)[0]
+        maskint = (0xFFFFFFFF << (32 - int(netmask))) & 0xFFFFFFFF
+        return ipint & maskint == netint
+    @staticmethod
+    def IPStr2int(addr):
+        """@brief Convert an IP address string to an integer.
+           @param addr The IP address string.
+           @return The integer represented by the IP address."""
+        return struct.unpack("!I", socket.inet_aton(addr))[0]
+    @staticmethod
+    def Int2IPStr(addr):
+        """@brief Convert an integer to an IP address string.
+           @param addr The Integer value of the IP address.
+           @return The string value (dotted quad) of the IP address."""
+        return socket.inet_ntoa(struct.pack("!I", addr))
+    @staticmethod
+    def NetmaskToBitCount(netmask):
+        """@brief Convert a dotted quad netmask to a bit count netmask format.
+           @param netmask: The dotted quad netmask (E.G 255.255.255.0)
+           @return: The netmask as a count of the set bits (E.G 24).
+        """
+        return sum([bin(int(x)).count('1') for x in netmask.split('.')])
+    @staticmethod
+    def BitCountToNetMask(bitCount):
+        """@brief Convert a bit count to a netmask string
+           @param bitCount The number of bits in the netmask.
+           @return The netmask string E.G 255.255.255.0"""
+        if bitCount > 32:
+            raise Exception("{} greater than 32".format(bitCount))
+        num=1
+        for _ in range(0,bitCount):
+            num=num>>1
+            num=num|0x80000000
+        return NetIF.Int2IPStr(num)
+    def __init__(self):
+        self._osName = platform.system()
+        self._checkSupportedOS()
+        self._ifDict = None
+    def getLocalNetworkAddress(self):
+        """@brief Get the IP address of the local interface that has the default route.
+                  The IP address will be the source IP address for packets are sent over the default route from this machine.
+                  This works on Windows, Linux, Android"""
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        sock.connect(('<broadcast>', 0))
+        netIPAddr = sock.getsockname()[0]
+        sock.close()
+        return netIPAddr
+    def getIFDict(self, readNow=False, includeNoIPIF = False):
+        """@param readNow If True the read the current network interface
+                          state now regardless of wether we have read it previously.
+                          If False and we have read the state of the network
+                          interfaces previously then return the previous state.
+           @param includeNoIPIF If True then interfaces with no IPaddress are included in the results.
+           @return A dict of the IP network interfaces on this platform.
+                       key   = name of interface
+                       value = A list of <IP ADDRESS>/<NET MASK BIT COUNT>"""
+        if self._ifDict and not readNow:
+            return self._ifDict
+        if self._osName.find(NetIF.LINUX_OS_NAME) >= 0 :
+            self._ifDict = self.getLinuxIFDict(includeNoIPIF=includeNoIPIF)
+        return self._ifDict
+    def getLinuxIFDict(self, includeNoIPIF = False):
+        """@brief Get a dic that contains the local interface details.
+           @param includeNoIPIF If True then interfaces with no IPaddress are included in the results.
+           @return A dict of the IP network interfaces on this platform.
+                       key   = name of interface
+                       value = A list of <IP ADDRESS>/<NET MASK BIT COUNT>"""
+        netIFDict = {}
+        cmdOutput = check_output(['/sbin/ip','a'] ).decode()
+        netIFDict = self._getLinuxIFDict(cmdOutput, includeNoIPIF=includeNoIPIF)
+        return netIFDict
+    def _getLinuxIFDict(self, cmdOutput, includeNoIPIF=False):
+        """@brief Get a dic that contains the local interface details.
+           @param cmdOutput The ip a command output.
+           @param includeNoIPIF If True then interfaces with no IPaddress are included in the results.
+           @return A dict of the IP network interfaces on this platform.
+                       key   = name of interface
+                       value = A list of <IP ADDRESS>/<NET MASK BIT COUNT>"""
+        netIFDict = {}
+        lines = cmdOutput.lower().split('\n')
+        ifName = None
+        ifAddressList = []
+        for line in lines:
+            elems = line.split(":")
+            try:
+                #If first element is the IF ID
+                #Note that the IF ID may not be sequential
+                int(elems[0])
+                #Extract the if name
+                if len(elems) > 1:
+                    ifName = elems[1].strip()
+                    ifName = ifName.replace(":", "")
+                    ifAddressList = []
+                    if includeNoIPIF:
+                        netIFDict[ifName] = ifAddressList
+            except:
+                line = line.strip()
+                if line.startswith("inet "):
+                    elems = line.split()
+                    if len(elems) > 1:
+                        ipAddress = elems[1]
+                        ifAddressList.append(ipAddress)
+                        netIFDict[ifName] = ifAddressList
+        return netIFDict
+    def getIFName(self, ipAddress):
+        """@brief Get the name of the interface which the ip address can be reached directly (not via an IP gateway)
+           @param ipAddress The IP address that should be out on an interface.
+           @return The dict entry for the interface.
+                   key == Interface name
+                   value = Interface address.
+           @return The name of the local network interface or None if not found."""
+        ifDict = self.getIFDict()
+        ifNames = list(ifDict.keys())
+        ifNames.sort()
+        for ifName in ifNames:
+            ipDetailsList = ifDict[ifName]
+            for ipDetails in ipDetailsList:
+                elems = ipDetails.split(NetIF.IP_NETMASK_SEP)
+                if len(elems) == 2:
+                    ipAddr     = elems[0]
+                    netMaskBits= int(elems[1])
+                    netMask = NetIF.BitCountToNetMask(netMaskBits)
+                    ipAddrInt  = NetIF.IPStr2int(ipAddr)
+                    netMaskInt = NetIF.IPStr2int(netMask)
+                    network = ipAddrInt&netMaskInt
+                    networkStr = socket.inet_ntoa(struct.pack("!I", network))
+                    netMaskInt=24
+                    if NetIF.IsAddressInNetwork(ipAddress, "%s/%s" % ( networkStr, netMaskInt) ):
+                        return ifName
+        return None
+    def _getIFDetails(self, ifName):
+        """@brief Get the details of the network interface on this machine given the interface name.
+           @param ifName The name of the interface.
+           @return A tuple containing the tuples that contain
+                  0: IP address
+                  1: Netmask"""
+        self.getIFDict()
+        if ifName in self._ifDict:
+            ifDetailsList = self._ifDict[ifName]
+            for ifDetails in ifDetailsList:
+                if ifDetails:
+                    elems = ifDetails.split(NetIF.IP_NETMASK_SEP)
+                    if len(elems) == 2:
+                        return elems
+        return None
+    def getIFIPAddress(self, ifName):
+        """@brief Get the IP address of the network interface on this machine given the interface name.
+           @param ifName The name of the interface.
+           @return The IP address oft heinterface of None if unknown."""
+        ifDetails = self._getIFDetails(ifName)
+        if ifDetails and len(ifDetails) == 2:
+            return ifDetails[0]
+        return None
+    def getIFNetmask(self, ifName):
+        """@brief Get the netmask of the network interface on this machine given the interface name.
+           @param ifName The name of the interface.
+           @return The IP address of the interface of None if unknown."""
+        ifDetails = self._getIFDetails(ifName)
+        if ifDetails and len(ifDetails) == 2:
+            netMaskBitCount = int(ifDetails[1])
+            return NetIF.BitCountToNetMask(netMaskBitCount)
+        return None
+    def _checkSupportedOS(self):
+        """@brief Check that the OS is supported."""
+        for supportedOSName in NetIF.SUPPORTED_OS_NAMES:
+            if self._osName.find(supportedOSName) != -1:
+                return
+        raise Exception("%s: %s is an unsupported platform", type(self).__name__, self._osName)