
Security News
Deno 2.2 Improves Dependency Management and Expands Node.js Compatibility
Deno 2.2 enhances Node.js compatibility, improves dependency management, adds OpenTelemetry support, and expands linting and task automation for developers.
Simple and secure TCP framework
Using pip:
$ pip install gtcp
In Python:
from gtcp import server, client
The server comes as a class. When creating a server with the class, the constructor takes 1 required parameter: the port the server will run on.
from gtcp import server
# 's' is a TCP server that runs on port 8080
s = server(8080)
Additionally, the server also takes 1 optional parameter: options. Options should be passed as a dictionary.
from gtcp import server
# in this case, we are setting the "encrypted" option to true
s = server(8080, {"encrypted": True})
Server objects have the .connection()
method to handle new client connections. It takes 1 parameter: a callback function with a parameter for the socket.
# The socket parameter will be set as an object that represents the connection
def connectionhandler(socket):
pass
s.connect(connectionhandler)
The socket object is comprised of the IP address of the client, the socket id, the rooms the socket is in, methods for handling and sending data, and methods for handling rooms.
def connectionhandler(socket):
print(socket.id)
# Output: A random UUIDv4 id
print(socket.ip)
# Output: 0.0.0.0
print(socket.rooms)
# Output: [<the id of the socket>, rooms, the, socket, is, in...]
s.connect(connectionhandler)
To send data, use the .emit()
method. It takes at least two parameters: the event and any amount of data to be sent.
You can use the .emit()
method with a server object or a socket object to send to all connected sockets or to a single socket respectively.
def connectionhandler(socket):
# This will send to the specific socket from the parameter
socket.emit("login", username, password)
# This will send to all sockets
s.emit("login", username, password)
s.connect(connectionhandler)
# This will send to all sockets
s.emit("login", username, password)
To recieve data from a socket, use it's .on()
method. It takes two parameters: the event and a callback function with parameters for all the data.
def connectionhandler(socket):
def loginhandler(username, password):
pass
socket.on("login", loginhandler)
s.connect(connectionhandler)
To do certain interactions with specific sockets or to simple group and organize sockets, use rooms. Rooms are groups of sockets that you can adress seperately from others.
To get a socket to join a room, use the .join()
method.
def connectionhandler(socket):
socket.join("room1")
print(socket.rooms)
# Output: [<the id of the socket>, "room1"]
s.connect(connectionhandler)
To get a socket to leave a room (excluding the room of their own id), use the .leave()
method.
def connectionhandler(socket):
socket.leave("room1")
print(socket.rooms)
# Output: [<the id of the socket>]
socket.leave(socket.id)
print(socket.rooms)
# Output: [<the id of the socket>]
s.connect(connectionhandler)
To get a socket to leave all tooms except for the one is their own id, use the .clearrooms()
method.
def connectionhandler(socket):
socket.clearrooms()
print(socket.rooms)
# Output: [<the id of the socket>]
s.connect(connectionhandler)
To send data to a specific room, use server object's .to()
method. It takes one parameter (the room). The .to()
methods can be chained to send to multiple rooms.
def connectionhandler(socket):
pass
socket.onconnection()
# This will emit to sockets in room1
socket.to("room1").emit("hello", "world")
# This will emit to both room1 and room2
socket.to("room1").to("room2").emit("hello", "world")
To a socket disconnect, listen with the .on()
method for a the "end" event. The callback function takes no parameters
def connectionhandler(socket):
def endhandler():
pass
socket.on("end", endhandler)
s.connect(connectionhandler)
The client comes as a class. When creating a client with the class, the constructor takes 1 required parameters: the IP address and port of the server to connect to.
from gtcp import client
# 'c' is a TCP client connected to a server ran on port 8080
c = client("localhost:8080")
Additionally it takes 2 more optional parameters: a callback function to run when the client connects to the server and an options dictionary.
from gtcp import client
# 'connectionhandler,' which is optional, is ran when it 'c' finishes connecting to the server
def clientcallback(c):
pass
# 'c' is an encrypted TCP client connected to a server ran on port 8080
c = client("localhost:8080", {"encrypted": True}, clientcallback)
To send data to the server, use the .emit()
method. It takes at least two parameters: the event and any amount of data to be sent.
def clientcallback(c):
# This will send to the server
c.emit("login", username, password)
c = client("localhost:8080", clientcallback)
# This also sends to the server
c.emit("login", username, password)
To recieve data from the server, use the client object's .on()
method. It takes two parameters: the event and a callback function with parameters for all the data.
def loginhandler(username, password):
pass
def clientcallback(c):
c.on("login", loginhandler)
c = client("localhost:8080", clientcallback)
# This also works
c.on("login", loginhandler)
Sometimes, it is useful to have a more traditional request-response style API. In GTCP, this is achieved with callback functions.
Callback functions are any functions that are sent through an .emit()
. The function will be ran and supplied with parameters when it is called by the other side.
# In client
def clientcallback(c):
def loginCallback(confirm, userToken=""):
if confirm:
print(userToken)
c.emit("login", username, password, loginCallback)
c = client("localhost:8080", clientcallback)
# In server
def connectionhandler(socket):
def loginhandler(username, password, callback):
if db.exists("username", username):
if db.where("username", username)["password"] == password:
callback(1, db.where("username", username)["userToken"])
else:
callback(0)
else:
callback(0)
socket.on("login", loginhandler)
s.connect(connectionhandler)
FAQs
Simple and secure TCP framework
We found that gtcp demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Deno 2.2 enhances Node.js compatibility, improves dependency management, adds OpenTelemetry support, and expands linting and task automation for developers.
Security News
React's CRA deprecation announcement sparked community criticism over framework recommendations, leading to quick updates acknowledging build tools like Vite as valid alternatives.
Security News
Ransomware payment rates hit an all-time low in 2024 as law enforcement crackdowns, stronger defenses, and shifting policies make attacks riskier and less profitable.