JSON packet transmitter

Your implementation is fatally flawed, and this is mostly not your fault: sockets are non-intuitive. First, when you say

receives json packets

that's not in the slightest what you're doing. You're sending JSON messages that happen to usually fit in one packet, and this coincidence is unreliable and will break under many, many common conditions. This trips up nearly every beginner socket programmer. You need to almost forget about packets entirely, assume that your message may be segmented into an arbitrary number of packets returned to the listener in a series of arbitrarily-sized byte buffers. This in turn means that you cannot rely on packet boundaries to be message boundaries. You need to define your own message boundary. One easy message boundary is a newline, and Python makes it easy to use a StreamRequestHandler that listens for a newline regardless of how many packets were received. So, to stabilise your implementation,

• Call them JSON messages, not JSON packets
• Use sendall, not send
• Don't use socket at all on the server side; instead use StreamRequestHandler and TCPServer
• Use rfile.readline() to guarantee a stable message boundary

Other assorted points:

• file with the filename of current time is a lie
• The server should not need to go through a JSON round-trip, and can just write the bytes out to a file - if you don't care about validating the data
• You should be using with context management to guarantee socket closure

Suggested

Server:

"""
Server-Side that receives json packets from client over the network using port
5000. Then it saves the json packet to a file with the filename of current time.
"""
import random
import string
from socketserver import StreamRequestHandler, TCPServer


def save_json(data: bytes) -> None:
    """Saves json packets to file and name it with id"""
    filename = ''.join(
        random.choice(string.digits)
        for _ in range(3)
    ) + '.json'
    with open(filename, 'wb') as f:
        f.write(data)
    print('saved to', filename)


class DumpHandler(StreamRequestHandler):
    def handle(self) -> None:
        """receive json packets from client"""
        print('connection from {}:{}'.format(*self.client_address))
        try:
            while True:
                data = self.rfile.readline()
                if not data:
                    break
                print('received', data.decode().rstrip())
                save_json(data)
        finally:
            print('disconnected from {}:{}'.format(*self.client_address))


def main() -> None:
    server_address = ('localhost', 5000)
    print('starting up on {}:{}'.format(*server_address))
    with TCPServer(server_address, DumpHandler) as server:
        print('waiting for a connection')
        server.serve_forever()


if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        pass

Client:

"""Sends random json packets to server over port 5000"""

import socket
import json
from random import randint
from time import time, sleep
from typing import Dict, Any

IP = "127.0.0.1"
PORT = 5000


def generate_json_message() -> Dict[str, Any]:
    # """Generate random json packet with hashed data bits"""
    return {
        "id": randint(1, 100),
        "timestamp": time(),
        "data": hash(str(randint(1, 100)))
    }


def send_json_message(
    sock: socket.socket,
    json_message: Dict[str, Any],
) -> None:
    """Send json packet to server"""
    message = (json.dumps(json_message) + '\n').encode()
    sock.sendall(message)
    print(f'{len(message)} bytes sent')


def main() -> None:
    with socket.socket() as sock:
        sock.connect((IP, PORT))
        while True:
            json_message = generate_json_message()
            send_json_message(sock, json_message)
            sleep(1)


if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        pass