Made ready for pypi

Author: benwjhack

LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2020 Ben Hack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,2 +1,44 @@
-# python-message
-A small socket wrapper used in my projects
+# python-simpleprotocol
+A small socket wrapper
+
+Used for sending code, subcode, parameters.
+Code: Integer
+Subcode: Integer
+Params: Array of strings
+
+
+Only has basic use, as shown in this example:
+
+
+Server:
+
+```
+
+import simpleprotocol
+
+server = simpleprotocol.SimpleServer(port=8080)
+
+while True:
+    handler = server.accept()
+    handler.send(0)
+    print(handler.get())
+    handler.send(1)
+    print(handler.get())
+
+
+```
+
+Client:
+
+```
+
+import simpleprotocol
+
+socket = simpleprotocol.SimpleProtocol()
+
+if socket.get().code:
+    socket.send(1, 0, ["That sounds good!"])
+else:
+    socket.send(1, 1, ["Oh dear, that's not right..."])
+
+```

client.py

@@ -0,0 +1,8 @@
+import simpleprotocol
+
+socket = simpleprotocol.SimpleProtocol(port=8080)
+
+if socket.get().code:
+    socket.send(1, 0, ["That sounds good!"])
+else:
+    socket.send(1, 1, ["Oh dear, that's not right..."])

python-message/__init__.py renamed to message/__init__.py

@@ -0,0 +1,11 @@
+import simpleprotocol
+
+server = simpleprotocol.SimpleServer(port=8080)
+
+while True:
+    handler = server.accept()
+    handler.send(0)
+    print(handler.get())
+    handler = server.accept()
+    handler.send(1)
+    print(handler.get())

python-message/message.py renamed to message/message.py

@@ -0,0 +1,22 @@
+import setuptools
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="simpleprotocol", # Replace with your own username
+    version="1.0.0",
+    author="Ben Hack",
+    author_email="[email protected]",
+    description="A package for using a basic protocol socket",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/Chinbob2515/python-message",
+    packages=setuptools.find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires='>=3.6',
+)

python-message/simpleprotocol.py renamed to message/simpleprotocol.py

@@ -0,0 +1,7 @@
+from .simpleprotocol import LOG, SimpleServer, SimpleProtocol
+
+__all__ = [
+    LOG,
+    SimpleServer,
+    SimpleProtocol
+]

python-message/socketwrapper.py renamed to message/socketwrapper.py

@@ -0,0 +1,50 @@
+
+class Message():
+	
+	def __init__(self, socket=None, LOG=False):
+		self.socket = socket
+		self.LOG = LOG
+	
+	def setSocket(self, sock):
+		self.socket = sock
+	
+	def encode(self, code, subcode, param):
+		if type(code) != int:
+			raise TypeError("Code must be an integer")
+		if type(subcode) != int:
+			raise TypeError("Subcode must be an integer")
+		if type(param) != list:
+			raise TypeError("Param must be a list")
+		param = [str(i).replace(":", "\c").replace(";", "\s").replace("\n", "\e") for i in param]
+		return str(code)+":"+str(subcode)+":"+';'.join(param)
+	
+	def decode(self, message):
+		info = {"code": None, "subcode": None, "params": []}
+		parts = message.split(":")
+		info["code"] = int(parts[0])
+		info["subcode"] = int(parts[1])
+		info["params"] = [i.replace("\c", ":").replace("\s", ";").replace("\e", "\n") for i in parts[2].split(";")]
+		return Packet(**info)
+	
+	def get(self):
+		raw = self.socket.readLine()
+		if not raw:
+			return Packet(-1)
+		result = self.decode(raw)
+		if self.LOG: print(result)
+		return result
+	
+	def send(self, code, subcode=0, param=[]):
+		self.socket.sendLine(self.encode(code, subcode, param))
+
+
+# basically a data class, but before 3.7
+class Packet:
+
+    def __init__(self, code, subcode=0, params=[]):
+        self.code = code
+        self.subcode = subcode
+        self.params = params
+
+    def __str__(self):
+        return f"{self.__class__.__name__}: <code:{self.code}, subcode:{self.subcode}, params:{self.params}>"

server.py

@@ -0,0 +1,31 @@
+from . import socketwrapper
+from . import message
+
+LOG = False
+
+class SimpleServer():
+
+    def __init__(self, port):
+        self.port = port
+        self.socket = socketwrapper.ServerSocket(port=port)
+
+    def accept(self):
+        return _SimpleProtocolForServer(self.socket.getClientObject())
+
+class SimpleProtocol():
+
+    def __init__(self, port):
+        self.socket = socketwrapper.ClientSocket(port=port)
+        self.message = message.Message(socket=self.socket)
+
+    def send(self, *args, **kwargs):
+        return self.message.send(*args, **kwargs)
+
+    def get(self, *args, **kwargs):
+        return self.message.get(*args, **kwargs)
+
+class _SimpleProtocolForServer(SimpleProtocol):
+
+    def __init__(self, socket):
+        self.socket = socket
+        self.message = message.Message(socket=self.socket)

setup.py

@@ -0,0 +1,88 @@
+import socket, sys
+
+ENCODING="UTF-8"
+
+class ServerSocket():
+	
+	def __init__(self, ip='localhost', port=10000):
+		self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+		self.server_address = (ip, port)
+		self.sock.bind(self.server_address)
+		self.sock.listen(1)
+	
+	def accept(self):
+		connection, client_address = self.sock.accept()
+		return [connection, client_address]
+	
+	def getClientObject(self):
+		return self.ServerSocketHandler(*self.accept())
+	
+	class ServerSocketHandler():
+		
+		def __init__(self, connection, client_address):
+			self.connection = connection
+			self.client_address = client_address
+			self.buffer = ""
+			self.alive = True
+		
+		def sendLine(self, line):
+			if not line.endswith("\n"): line += "\n"
+			self.connection.sendall(line.encode(ENCODING))
+		
+		def readLine(self):
+			while not "\n" in self.buffer:
+				try:
+					self.buffer += self.connection.recv(64).decode(ENCODING)
+				except ConnectionResetError:
+					self.close(response=1)
+					return None
+			line = self.buffer.split("\n")[0]
+			self.buffer = '\n'.join(self.buffer.split("\n")[1:])
+			self.tryExecOrder(line)
+			return line
+		
+		def tryExecOrder(self, line):
+			if "\k" in line:
+				self.close(response=1)
+		
+		def close(self, response=0):
+			if not response:
+				self.sendLine("\k")
+			else:
+				self.connection.close()
+				self.alive = False
+
+class ClientSocket():
+	
+	def __init__(self, ip="localhost", port=10000):
+		self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+		self.server_address = (ip, port)
+		self.sock.connect(self.server_address)
+		self.buffer = ""
+		self.alive = True
+	
+	def sendLine(self, line):
+		if not line.endswith("\n"): line += "\n"
+		self.sock.sendall(line.encode(ENCODING))
+	
+	def readLine(self):
+		while not "\n" in self.buffer:
+			try:
+				self.buffer += self.sock.recv(64).decode(ENCODING)
+			except ConnectionResetError:
+				self.close(response=1)
+				return None
+		line = self.buffer.split("\n")[0]
+		self.buffer = '\n'.join(self.buffer.split("\n")[1:])
+		self.tryExecOrder(line)
+		return line
+	
+	def tryExecOrder(self, line):
+		if "\k" in line:
+			self.close()
+	
+	def close(self):
+		self.sendLine("\k")
+		self.sock.close()
+		self.alive = False
+