javac 1.1.5__tar.gz

javac-1.1.5/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Chirag Vishwakarma
+
+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.

javac-1.1.5/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: javac
+Version: 1.1.5
+Summary: Teri Maa ne bhoot ke sath suhagrat rachai thi woh bhoot huh mein 
+Home-page: 
+Author: kya dekh rha hai luvday
+Author-email: xyz@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary

javac-1.1.5/javac/__init__.py

@@ -0,0 +1,28 @@
+import os
+
+def show_codes(filename: str = None):
+    """
+    Displays code from the scikit-learrnn package.
+    - If filename is given (without .py), shows that file's code.
+    - If no filename is given, shows all .py files.
+    """
+    base_path = os.path.dirname(__file__)
+    files = [f for f in os.listdir(base_path) if f.endswith(".py") and f != "__init__.py"]
+
+    if filename:
+        file_path = os.path.join(base_path, f"{filename}.py")
+        if os.path.exists(file_path):
+            print(f"\n=== Showing {filename}.py ===\n")
+            with open(file_path, "r", encoding="utf-8") as f:
+                print(f.read())
+        else:
+            print(f"\n❌ File '{filename}.py' not found in scikit-learrnn.\n")
+            print("Available files:")
+            for f in files:
+                print("•", f.replace(".py", ""))
+    else:
+        print("\nAll practical codes in scikit-learrnn:\n")
+        for f in files:
+            print(f"\n=== {f} ===\n")
+            with open(os.path.join(base_path, f), "r", encoding="utf-8") as file:
+                print(file.read())

javac-1.1.5/javac/calculator.py

@@ -0,0 +1,104 @@
+
+#calculator
+
+import java.net.*;
+class RPCServer {
+    DatagramSocket ds;
+    DatagramPacket dp;
+    String st1, methodName, result;
+    int val1, val2;
+    RPCServer() {
+        try {
+            ds = new DatagramSocket(1200);
+            byte b[] = new byte[1024];
+            System.out.println("RPC Server is running on port 1200...\n");
+            while (true) {
+                dp = new DatagramPacket(b, b.length);
+                ds.receive(dp);   // receive client request
+                st1 = new String(dp.getData(), 0, dp.getLength());
+                if (st1.equalsIgnoreCase("q")) {
+                    System.out.println("Server Stopped.");
+                    break;
+                }                
+                String arr[] = st1.split(" ");
+                methodName = arr[0];
+                val1 = Integer.parseInt(arr[1]);
+                val2 = Integer.parseInt(arr[2]);                
+                if (methodName.equalsIgnoreCase("sub"))
+                    result = String.valueOf(sub(val1, val2));
+                else if (methodName.equalsIgnoreCase("mul"))
+                    result = String.valueOf(mul(val1, val2));
+                else if (methodName.equalsIgnoreCase("div"))
+                    result = String.valueOf(div(val1, val2));
+                else if (methodName.equalsIgnoreCase("add"))
+                    result = String.valueOf(add(val1, val2));
+                else
+                    result = "Invalid Method";
+                byte b1[] = result.getBytes();
+                DatagramPacket dp1 = new DatagramPacket(
+                        b1,
+                        b1.length,
+                        dp.getAddress(),
+                        dp.getPort()
+                );
+                ds.send(dp1);
+                System.out.println("Client Request: " + st1);
+                System.out.println("Result Sent: " + result + "\n");
+            }
+            ds.close();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+    public int sub(int a, int b) {
+        return a - b;
+    }
+    public int add(int a, int b) {
+        return a + b;
+    }
+    public int mul(int a, int b) {
+        return a * b;
+    }
+    public int div(int a, int b) {
+        return a / b;
+    }
+    public static void main(String args[]) {
+        new RPCServer();
+    }
+}
+
+
+##
+import java.net.*;
+class RPCClient {
+    RPCClient() {
+        try {
+            DatagramSocket ds = new DatagramSocket();  // create socket
+            InetAddress ia = InetAddress.getLocalHost();
+            BufferedReader br = new BufferedReader(
+                    new InputStreamReader(System.in)
+            );
+            System.out.println("Enter method name and parameters like add 3 4:");
+            String s = br.readLine();   // take input
+            byte b[] = s.getBytes();
+            DatagramPacket dp = new DatagramPacket(
+                    b,
+                    b.length,
+                    ia,
+                    1200
+            );
+            ds.send(dp);   // send request
+            byte b1[] = new byte[1024];
+            dp = new DatagramPacket(b1, b1.length);
+            ds.receive(dp);   // receive response
+            String s2 = new String(dp.getData(), 0, dp.getLength());
+            System.out.println("\nResult = " + s2);
+            ds.close();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+    public static void main(String args[]) {
+        new RPCClient();
+    }
+}

javac-1.1.5/javac/chatting application.py

@@ -0,0 +1,117 @@
+#chatting application
+
+
+import java.net.*;
+import java.io.*;
+
+class ChatServer {
+
+    public static void main(String args[]) {
+
+        try {
+            // Create server socket on port 8000
+            ServerSocket ss = new ServerSocket(8000);
+            System.out.println("Waiting for client to connect...");
+
+            // Accept client connection
+            Socket s = ss.accept();
+            System.out.println("Client connected!");
+
+            // Read from client
+            BufferedReader br = new BufferedReader(
+                    new InputStreamReader(s.getInputStream()));
+
+            // Read from server keyboard
+            BufferedReader keyboard = new BufferedReader(
+                    new InputStreamReader(System.in));
+
+            // Send to client
+            DataOutputStream out =
+                    new DataOutputStream(s.getOutputStream());
+
+            String receive, send;
+
+            // Continuous chat
+            while ((receive = br.readLine()) != null) {
+
+                // Display client message
+                System.out.println("Client says: " + receive);
+
+                // Type reply from server
+                send = keyboard.readLine();
+
+                // Send reply
+                out.writeBytes(send + "\n");
+            }
+
+            // Close all connections
+            br.close();
+            keyboard.close();
+            out.close();
+            s.close();
+            ss.close();
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+
+#
+import java.net.*;
+import java.io.*;
+
+class ChatClient {
+
+    public static void main(String args[]) {
+
+        try {
+            // Connect to server
+            Socket s = new Socket("localhost", 8000);
+            System.out.println("Connected to server!");
+
+            // Keyboard input
+            BufferedReader keyboard = new BufferedReader(
+                    new InputStreamReader(System.in));
+
+            // Read from server
+            BufferedReader in = new BufferedReader(
+                    new InputStreamReader(s.getInputStream()));
+
+            // Send to server
+            DataOutputStream out =
+                    new DataOutputStream(s.getOutputStream());
+
+            String msg, reply;
+
+            System.out.println("Type STOP to end chat");
+
+            // Continuous chat
+            while (true) {
+
+                // Send message
+                msg = keyboard.readLine();
+                out.writeBytes(msg + "\n");
+
+                if (msg.equalsIgnoreCase("STOP"))
+                    break;
+
+                // Receive reply
+                reply = in.readLine();
+                System.out.println("Server says: " + reply);
+            }
+
+            // Close all resources
+            keyboard.close();
+            in.close();
+            out.close();
+            s.close();
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+

javac-1.1.5/javac/current date and time.py

@@ -0,0 +1,78 @@
+##save as InterDate.java
+
+import java.rmi.Remote;
+import java.rmi.RemoteException;
+
+public interface InterDate extends Remote {
+
+    // Remote method must throw RemoteException
+    String display() throws RemoteException;
+}
+
+
+##
+
+ ##save as ClientDate.java
+import java.rmi.Naming;
+
+public class ClientDate {
+
+    public static void main(String[] args) {
+        try {
+            // Lookup remote object
+            InterDate stub = (InterDate) Naming.lookup("rmi://localhost:1099/DS");
+
+            // Call remote method
+            String date = stub.display();
+
+            // Display result
+            System.out.println("Current Date and Time from Server:");
+            System.out.println(date);
+        } 
+        catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
+## save as ServerDate
+import java.rmi.Naming;
+import java.rmi.RemoteException;
+import java.rmi.registry.LocateRegistry;
+import java.rmi.server.UnicastRemoteObject;
+import java.util.Date;
+
+public class ServerDate extends UnicastRemoteObject implements InterDate {
+
+    // Constructor
+    protected ServerDate() throws RemoteException {
+        super();
+    }
+
+    // Implementation of remote method
+    public String display() throws RemoteException {
+        return new Date().toString();
+    }
+
+    // Main method
+    public static void main(String[] args) {
+        try {
+            // Start RMI registry at port 1099
+            LocateRegistry.createRegistry(1099);
+
+            // Create remote object
+            ServerDate server = new ServerDate();
+
+            // Bind object to registry
+            Naming.rebind("rmi://localhost:1099/DS", server);
+
+            System.out.println("Server is running and object registered...");
+        } 
+        catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+run javac *.java
+java ServerDate
+java ClientDate

javac-1.1.5/javac/even odd.py

@@ -0,0 +1,82 @@
+## even odd
+
+import java.io.*;
+import java.net.*;
+public class prac4server{
+    public static void main(String args[]) {
+        try {            
+            DatagramSocket ds = new DatagramSocket(2000);
+            byte b[] = new byte[1024];           
+            DatagramPacket dp = new DatagramPacket(b, b.length);
+            ds.receive(dp);
+            // Convert received bytes into string
+            String str = new String(dp.getData(), 0, dp.getLength());
+            System.out.println("Received number: " + str);
+            // Convert string to integer
+            int a = Integer.parseInt(str);
+            String s;
+            // Check even or odd
+            if (a % 2 == 0)
+                s = "Number is Even";
+            else
+                s = "Number is Odd";
+            // Convert result into byte array
+            byte b1[] = s.getBytes();
+            // Send result back to client
+            DatagramPacket dp1 = new DatagramPacket(
+                    b1,
+                    b1.length,
+                    dp.getAddress(),
+                    dp.getPort()
+            );
+            ds.send(dp1);
+            ds.close();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+
+##
+
+
+Folder highlights
+Java programs implement a UDP client-server check to determine if an entered number is even or odd.
+
+import java.io.*;
+import java.net.*;
+public class prac4client {
+    public static void main(String args[]) {
+        try {
+            // Create socket on port 1000
+            DatagramSocket ds = new DatagramSocket(1000);
+            // Take input from user
+            BufferedReader br = new BufferedReader(
+                    new InputStreamReader(System.in)
+            );
+            System.out.println("Enter a number:");
+            String num = br.readLine();
+            // Convert input to bytes
+            byte b[] = num.getBytes();
+            // Create packet to send to server (port 2000)
+            DatagramPacket dp = new DatagramPacket(
+                    b,
+                    b.length,
+                    InetAddress.getLocalHost(),
+                    2000
+            );
+            ds.send(dp);
+            // Receive response from server
+            byte b1[] = new byte[1024];
+            DatagramPacket dp1 = new DatagramPacket(b1, b1.length);
+            ds.receive(dp1);
+            // Convert response to string
+            String str = new String(dp1.getData(), 0, dp1.getLength());
+            System.out.println("Server Response: " + str);
+            ds.close();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}

javac-1.1.5/javac/multicast socket.py

@@ -0,0 +1,84 @@
+import java.net.*;
+
+public class BroadcastClient {
+
+    public static final int PORT = 1234;
+
+    public static void main(String[] args) throws Exception {
+
+        InetAddress group = InetAddress.getByName("239.1.2.3");
+
+        // Create socket properly (modern way)
+        MulticastSocket socket = new MulticastSocket(null);
+        socket.setReuseAddress(true);
+        socket.bind(new InetSocketAddress(PORT));
+
+        // Get network interface
+        NetworkInterface networkInterface =
+                NetworkInterface.getByInetAddress(InetAddress.getLocalHost());
+
+        // Join multicast group
+        socket.joinGroup(new InetSocketAddress(group, PORT), networkInterface);
+
+        System.out.println("Client started. Waiting for messages...");
+
+        byte[] buffer = new byte[1024];
+
+        while (true) {
+            DatagramPacket packet =
+                    new DatagramPacket(buffer, buffer.length);
+
+            socket.receive(packet);
+
+            String message = new String(
+                    packet.getData(), 0, packet.getLength());
+
+            System.out.println("Message received from "
+                    + packet.getAddress()
+                    + " : " + message);
+        }
+    }
+}
+
+
+###
+import java.net.*;
+
+public class BroadcastServer {
+
+    public static final int PORT = 1234;
+
+    public static void main(String[] args) throws Exception {
+
+        // Multicast group address
+        InetAddress group = InetAddress.getByName("239.1.2.3");
+
+        // Create multicast socket
+        MulticastSocket socket = new MulticastSocket();
+
+        // Optional: keep multicast within local network
+        socket.setTimeToLive(1);
+
+        // Wait for 10 seconds before sending
+        Thread.sleep(10000);
+
+        System.out.println("Sending message...");
+
+        String message = "This is Mohit calling...";
+        byte[] buffer = message.getBytes();
+
+        // Create datagram packet
+        DatagramPacket packet =
+                new DatagramPacket(buffer, buffer.length, group, PORT);
+
+        // Send packet
+        socket.send(packet);
+
+        System.out.println("Message sent successfully.");
+
+        socket.close();
+    }
+}
+run javac *.java
+java BroadcastClient
+java BroadcastServer

javac-1.1.5/javac/prime no.py

@@ -0,0 +1,100 @@
+#prime no
+#client 
+import java.net.*;
+import java.io.*;
+
+class ClientLine {
+    public static void main(String args[]) {
+        try {
+            // Create socket connection to localhost on port 8001
+            Socket s = new Socket("localhost", 8001);
+
+            // Read input from keyboard
+            BufferedReader br = new BufferedReader(
+                    new InputStreamReader(System.in));
+
+            System.out.print("Enter number: ");
+            int a = Integer.parseInt(br.readLine());
+
+            // Send data to server
+            DataOutputStream out =
+                    new DataOutputStream(s.getOutputStream());
+            out.writeInt(a);
+
+            // Receive data from server
+            DataInputStream in =
+                    new DataInputStream(s.getInputStream());
+            System.out.println(in.readUTF());
+
+            // Close socket
+            s.close();
+        }
+        catch (Exception e) {
+            System.out.println(e.toString());
+        }
+    }
+}
+
+#server
+
+
+Folder highlights
+Java programs implement a TCP client and server to check if an integer input is prime over port 8001.
+
+import java.net.*;
+import java.io.*;
+
+class ServerLine {
+
+    public static void main(String args[]) {
+
+        try {
+            // Create server socket at port 8001
+            ServerSocket ss = new ServerSocket(8001);
+
+            System.out.println("Server started... Waiting for client");
+
+            // Accept client connection
+            Socket s = ss.accept();
+
+            // Read number from client
+            DataInputStream in =
+                    new DataInputStream(s.getInputStream());
+
+            int x = in.readInt();
+
+            // Send result back to client
+            DataOutputStream out =
+                    new DataOutputStream(s.getOutputStream());
+
+            boolean isPrime = true;
+
+            if (x <= 1) {
+                isPrime = false;
+            } else {
+                for (int i = 2; i <= x / 2; i++) {
+                    if (x % i == 0) {
+                        isPrime = false;
+                        break;
+                    }
+                }
+            }
+
+            if (isPrime) {
+                out.writeUTF(x + " is prime");
+            } else {
+                out.writeUTF(x + " is not prime");
+            }
+
+            // Close connection
+            s.close();
+            ss.close();
+
+        } catch (Exception e) {
+            System.out.println(e.toString());
+        }
+    }
+}
+
+
+

javac-1.1.5/javac.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: javac
+Version: 1.1.5
+Summary: Teri Maa ne bhoot ke sath suhagrat rachai thi woh bhoot huh mein 
+Home-page: 
+Author: kya dekh rha hai luvday
+Author-email: xyz@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary

javac-1.1.5/javac.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+setup.py
+javac/__init__.py
+javac/calculator.py
+javac/chatting application.py
+javac/current date and time.py
+javac/even odd.py
+javac/multicast socket.py
+javac/prime no.py
+javac.egg-info/PKG-INFO
+javac.egg-info/SOURCES.txt
+javac.egg-info/dependency_links.txt
+javac.egg-info/top_level.txt

javac-1.1.5/javac.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

javac-1.1.5/javac.egg-info/top_level.txt

@@ -0,0 +1 @@
+javac

javac-1.1.5/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

javac-1.1.5/setup.py

@@ -0,0 +1,26 @@
+from setuptools import setup, find_packages
+import io
+import os
+
+def read(fname):
+    return io.open(os.path.join(os.path.dirname(__file__), fname), encoding="utf-8").read()
+
+setup(
+    name="javac",  # must be unique on PyPI
+    version="1.1.5",
+    author="kya dekh rha hai luvday",
+    author_email="xyz@gmail.com",
+    description="Teri Maa ne bhoot ke sath suhagrat rachai thi woh bhoot huh mein ",
+    long_description=read("README.md"),
+    long_description_content_type="text/markdown",
+    url="",  # optional
+    packages=find_packages(),
+    include_package_data=True,
+    install_requires=[],
+    license="MIT",  # ✅ SPDX-compliant license declaration
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.6",
+)