Introduction
Hello, Guys on this tutorial I will guide you to building a command-line chatting app in Python using sockets.
Note
If you had never had previous experience with sockets worry out I will explain everything detailed.
What are sockets?
sockets are two endpoints that can talk to each other ranging from the same on a machine or on wireless devices that are far away from each other.
Socket programming is a way of making two nodes on a network to communicate with each other. One socket listens on a particular port at an IP( server ), while another socket reaches out to the other to form a connection( client ).
The socket programming is the backbone of the internet system itself, deep down all these communication, we see now days arise from point to point communication.
Python socket module comes by default with the Python standard library therefore you don’t need to install anything to get started.
Structure of our Project
As we have seen above sockets are nodes that talk to each other, and in our project, we will implement two nodes using sockets one as a client and the other as a server.
Those two nodes will be sending messages two to each other as normal chatting applications.
Python socket programming
Getting started with sockets is very easy, you can use socket in various bidirectional communication, for instance, we can use them to get the IP from the hostname as shown below
Python 3.5.3 (default, Sep 27 2018, 17:25:39)
[GCC 6.3.0 20170516] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import socket
>>> socket.gethostname() #getting our local host name
'kalebu-PC'
>>> socket.gethostbyname('www.google.com') #getting IP of Google
'172.217.170.4'
As we can see in the above example we were able to get our local hostname using **gethostname **method and also we were able to get the Ip address of Google using gethostbyname method.
Building our First Socket(node)
There are many communication protocols for bi-directional communication it all comes out to out to where is being applied.
Example of communication protocols include Transmission communication Protocol (TCP), User Datagram Protocol (UDP), File Transfer Protocol (FTP) and etc
On building our Chatting application we are going to use Transmission communication protocol (TCP), knowing how it works will be appreciated but you don't really need to.
Let's create our first node
On creating a socket(node) in python for TCP we are going to pass to the main parameters which are
- socket.AF_INET means socket belong to IPV4 Family
- socket.SOCK_STREAM means connection configured using TCP Protocol
Write the following on your python shell to create your first node in python
>>> import socket
>>> node = socket.socket(socket.AF_INET, socket.SOCK_SaTREAM)
Congratulations you have just your first node in python, now let’s proceed to really building our application.
We need to have two separate node on two python scripts whereby one node will serve as a server and the other one as a client. Now Let's begin building our server node
Building Server node
I’m a great fan of object **oriented programming ( OPP )* , I used a class to abstractly define my server node with implemented method to recieve and send communication from the client.
Note
During listening our server is waiting, therefore our code won't receive multiple SMS send from client to tackle this we need to apply multithreading, therefore I did the same to receiving method so as it can keep receiving independently without blocking the our app
Below is a complete code for our server script , I'm gonna explain in details later now just proof read it
import socket
import threading
class ServerNode:
def __init__(self):
self.node = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
port_and_ip = ('127.0.0.1', 12345)
self.node.bind(port_and_ip)
self.node.listen(5)
self.connection, addr = self.node.accept()
def send_sms(self, SMS):
self.connection.send(SMS.encode())
def receive_sms(self):
while True:
data = self.connection.recv(1024).decode()
print(data)
def main(self):
while True:
message = input()
self.send_sms(message)
server = ServerNode()
always_receive = threading.Thread(target=server.receive_sms)
always_receive.daemon = True
always_receive.start()
server.main()
Code Explanation
Binding Ip address and port
port_and_ip = ('127.0.0.1', 12345)
self.node.bind(port_and_ip)
Binding* Ip addres*s and port to our node it’s like we are declaring in house of Ip address in the room of port that’s where our server node lives , therefore client have to come to this room to connect.
Which means client node must mention exactly server ip and port in order to connect.
In this demo we ran both two separate scripts on single machine, but the code also works over two seprate PC you just need to be on the same network.
Listening to Incoming connection
self.node.listen(5)
self.connection, addr = self.node.accept()
The above server code,It tells the server node to listen to incoming connections from a client and then accept connection when connection is found .
send_sms ( ) method
def send_sms(self, SMS):
self.connection.send(SMS.encode())
This method with only one line of code accept the SMS as parameter and send it to the client node, note that in order to send SMS using sockets it have to be in binary thus why we have encoded it .
receive_sms ( ) method
def receive_sms(self):
while True:
data = self.connection.recv(1024).decode()
print(data)
This method is used to receive **the message from the **client through out the program life, we have ** threaded** it so as to prevent the app from freezing.
Main ( ) method
def main(self):
while True:
message = input()
self.send_sms(message)
This method is used to prompt **a message from server and send** it to clients
Finishing things up
server = ServerNode()
always_receive = threading.Thread(target=server.receive_sms)
always_receive.daemon = True
always_receive.start()
server.main()
The above 5 lines of code are for creating a server instance and then run it by threading the receiving method
Building Client Node
Almost everything on Server node is similar to client node except the fact that client node connect to server instead of listening from connection , therefore big difference is seen on Constructor but Everything is almost the same.
import socket
import threading
class ClientNode:
def __init__(self):
self.node = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
port_and_ip = ('127.0.0.1', 12345)
self.node.connect(port_and_ip)
def send_sms(self, SMS):
self.node.send(SMS.encode())
def receive_sms(self):
while True:
data = self.node.recv(1024).decode()
print(data)
def main(self):
while True:
message = input()
self.send_sms(message)
Client = ClientNode()
always_receive = threading.Thread(target=Client.receive_sms)
always_receive.daemon = True
always_receive.start()
Client.main()
Once you run the code the output will be something as below, please make sure to start running a Server.py before running Client.py.
Well, that's all, If you did everything as shown above your two nodes should up running ready to send each other messages.
If you find this tutorial interesting, Don't be shy to share it with your fellow peers.
The Original Article can be found in kalebujordan.dev
Kalebu
/
Commandline-chatting-system-python
A simple CLI chat application made in Python using sockets
Commandline chat app in Python
Intro
Hi Guys this repo consist of a source code for a simple CLI chatting app made using sockets in Python
The original article
This repo is continuation of an Article on my blog so you might wanna review it to see a more brief tutorial on how it all works out.
Getting started
To get started just clone the repository using git command or pressing download button option at the right side of the repository
Cloning
$ git clone https://github.com/Kalebu/Commandline-chatting-system-python
$ cd Commandline-chatting-system-python
Commandline-chatting-system-python $ tree
.
├── client.py
├── README.md
└── server.py
0 directories, 3 files
This repo consist of two Python scripts named client.py and server.pyas I have explained on the tutorial, whereby server.py will serve as our server node and client.py will serve as our client node.
Running our scipt
Note
You should start running the server script before running…
Top comments (2)
How we can desing the chat layout for terminal appliaction.
Sure you can add it, just fork and submit your pull request