jx-gui 1.0.0__tar.gz

jx_gui-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mr. Inosuke
+
+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.

jx_gui-1.0.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: jx_gui
+Version: 1.0.0
+Summary: Turn simple print() and input() programs into a GUI window with one line of code.
+Author-email: "Mr. Inosuke" <inosukehasibira149@gmail.com>
+License-Expression: MIT
+Keywords: gui,beginner,tkinter,print,input,education
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Education
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# jx_gui
+
+Turn a simple `print()` / `input()` program into a GUI window with one line.
+Made for beginners who only know `print`, `input` and `if / else`.
+
+## Install
+
+```
+pip install jx_gui
+```
+
+On Linux you may also need tkinter: `sudo apt install python3-tk`
+
+## Use
+
+Put your normal code inside a function, then pass that function to `win` (Windows) or `lix` (Linux):
+
+```python
+import jx_gui
+
+def code():
+    num_1 = int(input("Number 1 : "))
+    num_2 = int(input("Number 2 : "))
+    op = input("Operator (+ - * /) : ")
+
+    if op == "+":
+        print("Result :", num_1 + num_2)
+    elif op == "-":
+        print("Result :", num_1 - num_2)
+    elif op == "*":
+        print("Result :", num_1 * num_2)
+    elif op == "/":
+        if num_2 == 0:
+            print("Cannot divide by 0")
+        else:
+            print("Result :", num_1 / num_2)
+    else:
+        print("Wrong operator")
+
+jx_gui.win(code)     # Windows
+# jx_gui.lix(code)   # Linux
+```
+
+Write `jx_gui.win(code)`, not `jx_gui.win(code())`.
+
+## How it behaves
+
+- `print()` shows the text in the window.
+- `input("text")` shows the text above an input box. Press **Ok** (or Enter) to continue.
+- Any `print()` or `input()` that is inside an `if / elif / else` appears as a popup with an **Ok** button.
+- If your code crashes, the error is shown in the window and in a popup.
+
+## License
+
+MIT

jx_gui-1.0.0/README.md

@@ -0,0 +1,55 @@
+# jx_gui
+
+Turn a simple `print()` / `input()` program into a GUI window with one line.
+Made for beginners who only know `print`, `input` and `if / else`.
+
+## Install
+
+```
+pip install jx_gui
+```
+
+On Linux you may also need tkinter: `sudo apt install python3-tk`
+
+## Use
+
+Put your normal code inside a function, then pass that function to `win` (Windows) or `lix` (Linux):
+
+```python
+import jx_gui
+
+def code():
+    num_1 = int(input("Number 1 : "))
+    num_2 = int(input("Number 2 : "))
+    op = input("Operator (+ - * /) : ")
+
+    if op == "+":
+        print("Result :", num_1 + num_2)
+    elif op == "-":
+        print("Result :", num_1 - num_2)
+    elif op == "*":
+        print("Result :", num_1 * num_2)
+    elif op == "/":
+        if num_2 == 0:
+            print("Cannot divide by 0")
+        else:
+            print("Result :", num_1 / num_2)
+    else:
+        print("Wrong operator")
+
+jx_gui.win(code)     # Windows
+# jx_gui.lix(code)   # Linux
+```
+
+Write `jx_gui.win(code)`, not `jx_gui.win(code())`.
+
+## How it behaves
+
+- `print()` shows the text in the window.
+- `input("text")` shows the text above an input box. Press **Ok** (or Enter) to continue.
+- Any `print()` or `input()` that is inside an `if / elif / else` appears as a popup with an **Ok** button.
+- If your code crashes, the error is shown in the window and in a popup.
+
+## License
+
+MIT

jx_gui-1.0.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "jx_gui"
+version = "1.0.0"
+description = "Turn simple print() and input() programs into a GUI window with one line of code."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Mr. Inosuke", email = "inosukehasibira149@gmail.com" },
+]
+keywords = ["gui", "beginner", "tkinter", "print", "input", "education"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Education",
+    "Programming Language :: Python :: 3",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Topic :: Education",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

jx_gui-1.0.0/setup.cfg

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

jx_gui-1.0.0/src/jx_gui/__init__.py

@@ -0,0 +1,7 @@
+"""jx_gui - turn simple print() / input() programs into a GUI window."""
+
+from ._windows import win
+from ._linux import lix
+
+__all__ = ["win", "lix"]
+__version__ = "1.0.0"

jx_gui-1.0.0/src/jx_gui/_core.py

@@ -0,0 +1,250 @@
+"""Shared engine for jx_gui (used by both the Windows and the Linux entry points)."""
+
+import ast
+import builtins
+import linecache
+import sys
+import tkinter as tk
+import traceback
+from tkinter import ttk
+
+
+class _Closed(Exception):
+    """Raised inside the user's code when the window is closed."""
+
+
+# ---------------------------------------------------------------------------
+# Finding out whether a print()/input() call sits inside if / elif / else
+# ---------------------------------------------------------------------------
+
+_if_cache = {}
+
+
+def _if_lines(filename):
+    """Line numbers of the file that belong to an if / elif / else block."""
+    if filename not in _if_cache:
+        lines = set()
+        try:
+            tree = ast.parse("".join(linecache.getlines(filename)))
+            for node in ast.walk(tree):
+                if isinstance(node, ast.If):
+                    end = getattr(node, "end_lineno", node.lineno)
+                    lines.update(range(node.lineno, end + 1))
+        except Exception:
+            pass
+        _if_cache[filename] = lines
+    return _if_cache[filename]
+
+
+def _in_if(depth):
+    try:
+        frame = sys._getframe(depth)
+    except ValueError:
+        return False
+    return frame.f_lineno in _if_lines(frame.f_code.co_filename)
+
+
+# ---------------------------------------------------------------------------
+# The window
+# ---------------------------------------------------------------------------
+
+class _App:
+    def __init__(self, title, font, mono):
+        self.font = font
+        self.closed = False
+        self.waiting = False
+
+        self.root = tk.Tk()
+        self.root.title(title)
+        self.root.geometry("560x460")
+        self.root.minsize(360, 300)
+        self.root.protocol("WM_DELETE_WINDOW", self._close)
+        self.answer = tk.StringVar(self.root)
+
+        bottom = ttk.Frame(self.root, padding=8)
+        bottom.pack(side="bottom", fill="x")
+
+        self.prompt = ttk.Label(bottom, text="", font=font, anchor="w", justify="left")
+        self.prompt.pack(fill="x")
+
+        row = ttk.Frame(bottom)
+        row.pack(fill="x", pady=(4, 0))
+        self.entry = ttk.Entry(row, font=font, state="disabled")
+        self.entry.pack(side="left", fill="x", expand=True)
+        self.ok = ttk.Button(row, text="Ok", state="disabled", command=self._submit)
+        self.ok.pack(side="left", padx=(8, 0))
+        self.entry.bind("<Return>", lambda e: self._submit())
+
+        area = ttk.Frame(self.root)
+        area.pack(side="top", fill="both", expand=True)
+        scroll = ttk.Scrollbar(area)
+        scroll.pack(side="right", fill="y")
+        self.out = tk.Text(area, state="disabled", wrap="word", font=mono,
+                           padx=8, pady=8, relief="flat", yscrollcommand=scroll.set)
+        self.out.pack(side="left", fill="both", expand=True)
+        scroll.config(command=self.out.yview)
+
+    # -- closing ------------------------------------------------------------
+
+    def _close(self):
+        self.closed = True
+        if self.waiting:
+            self.answer.set("")  # wake up the waiting input()/popup
+        else:
+            self.destroy()
+
+    def destroy(self):
+        try:
+            self.root.destroy()
+        except tk.TclError:
+            pass
+
+    def _check(self):
+        if self.closed:
+            raise _Closed()
+
+    # -- output -------------------------------------------------------------
+
+    def write(self, text):
+        self._check()
+        self.out.configure(state="normal")
+        self.out.insert("end", text)
+        self.out.see("end")
+        self.out.configure(state="disabled")
+        self.root.update_idletasks()
+
+    # -- waiting for the user -----------------------------------------------
+
+    def _submit(self):
+        if self.waiting:
+            self.answer.set(self.entry.get())
+
+    def _wait(self):
+        self.waiting = True
+        try:
+            self.root.wait_variable(self.answer)
+        finally:
+            self.waiting = False
+        self._check()
+        return self.answer.get()
+
+    # -- input inside the window --------------------------------------------
+
+    def ask(self, prompt):
+        self._check()
+        self.prompt.configure(text=prompt)
+        self.entry.configure(state="normal")
+        self.ok.configure(state="normal")
+        self.entry.delete(0, "end")
+        self.entry.focus_set()
+        try:
+            text = self._wait()
+        finally:
+            if not self.closed:
+                self.entry.configure(state="disabled")
+                self.ok.configure(state="disabled")
+                self.prompt.configure(text="")
+        self.write(prompt + text + "\n")
+        return text
+
+    # -- popup (used inside if / elif / else) -------------------------------
+
+    def popup(self, message, ask=False):
+        self._check()
+        top = tk.Toplevel(self.root)
+        top.title(self.root.title())
+        top.transient(self.root)
+        top.resizable(False, False)
+
+        frame = ttk.Frame(top, padding=16)
+        frame.pack()
+        ttk.Label(frame, text=message, font=self.font, wraplength=360,
+                  justify="left").pack(anchor="w")
+
+        entry = None
+        if ask:
+            entry = ttk.Entry(frame, font=self.font, width=40)
+            entry.pack(fill="x", pady=(8, 0))
+
+        def done(event=None):
+            self.answer.set(entry.get() if entry is not None else "")
+
+        button = ttk.Button(frame, text="Ok", command=done)
+        button.pack(anchor="e", pady=(12, 0))
+        top.bind("<Return>", done)
+        top.protocol("WM_DELETE_WINDOW", done)
+
+        top.update_idletasks()
+        x = self.root.winfo_rootx() + (self.root.winfo_width() - top.winfo_reqwidth()) // 2
+        y = self.root.winfo_rooty() + (self.root.winfo_height() - top.winfo_reqheight()) // 2
+        top.geometry("+%d+%d" % (max(x, 0), max(y, 0)))
+
+        try:
+            top.wait_visibility()
+            top.grab_set()
+        except tk.TclError:
+            pass
+        (entry or button).focus_set()
+
+        try:
+            return self._wait()
+        finally:
+            try:
+                top.destroy()
+            except tk.TclError:
+                pass
+
+
+# ---------------------------------------------------------------------------
+# Public runner
+# ---------------------------------------------------------------------------
+
+def run(code, title, font, mono):
+    if not callable(code):
+        raise TypeError("jx_gui: pass the function itself, like win(code) - not win(code())")
+
+    app = _App(title, font, mono)
+    real_print = builtins.print
+    real_input = builtins.input
+
+    def _print(*args, sep=" ", end="\n", file=None, flush=False):
+        if file is not None:
+            return real_print(*args, sep=sep, end=end, file=file, flush=flush)
+        joiner = " " if sep is None else sep
+        text = joiner.join(str(a) for a in args) + ("\n" if end is None else end)
+        if _in_if(2):
+            if text.strip():
+                app.popup(text.rstrip("\n"))
+        else:
+            app.write(text)
+
+    def _input(prompt=""):
+        prompt = str(prompt)
+        if _in_if(2):
+            return app.popup(prompt, ask=True)
+        return app.ask(prompt)
+
+    builtins.print = _print
+    builtins.input = _input
+    try:
+        code()
+    except _Closed:
+        pass
+    except Exception as error:
+        try:
+            app.write("\n" + traceback.format_exc())
+            app.popup("Error: %s: %s" % (type(error).__name__, error))
+        except _Closed:
+            pass
+    finally:
+        builtins.print = real_print
+        builtins.input = real_input
+
+    if app.closed:
+        app.destroy()
+        return
+    try:
+        app.write("\n--- finished ---\n")
+    except _Closed:
+        return
+    app.root.mainloop()

jx_gui-1.0.0/src/jx_gui/_linux.py

@@ -0,0 +1,7 @@
+"""Linux entry point: jx_gui.lix(code)"""
+
+from ._core import run
+
+
+def lix(code, title="jx_gui"):
+    run(code, title, ("DejaVu Sans", 11), ("DejaVu Sans Mono", 11))

jx_gui-1.0.0/src/jx_gui/_windows.py

@@ -0,0 +1,12 @@
+"""Windows entry point: jx_gui.win(code)"""
+
+from ._core import run
+
+
+def win(code, title="jx_gui"):
+    try:  # sharp text on high-DPI screens
+        import ctypes
+        ctypes.windll.shcore.SetProcessDpiAwareness(1)
+    except Exception:
+        pass
+    run(code, title, ("Segoe UI", 11), ("Consolas", 11))

jx_gui-1.0.0/src/jx_gui.egg-info/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: jx_gui
+Version: 1.0.0
+Summary: Turn simple print() and input() programs into a GUI window with one line of code.
+Author-email: "Mr. Inosuke" <inosukehasibira149@gmail.com>
+License-Expression: MIT
+Keywords: gui,beginner,tkinter,print,input,education
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Education
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# jx_gui
+
+Turn a simple `print()` / `input()` program into a GUI window with one line.
+Made for beginners who only know `print`, `input` and `if / else`.
+
+## Install
+
+```
+pip install jx_gui
+```
+
+On Linux you may also need tkinter: `sudo apt install python3-tk`
+
+## Use
+
+Put your normal code inside a function, then pass that function to `win` (Windows) or `lix` (Linux):
+
+```python
+import jx_gui
+
+def code():
+    num_1 = int(input("Number 1 : "))
+    num_2 = int(input("Number 2 : "))
+    op = input("Operator (+ - * /) : ")
+
+    if op == "+":
+        print("Result :", num_1 + num_2)
+    elif op == "-":
+        print("Result :", num_1 - num_2)
+    elif op == "*":
+        print("Result :", num_1 * num_2)
+    elif op == "/":
+        if num_2 == 0:
+            print("Cannot divide by 0")
+        else:
+            print("Result :", num_1 / num_2)
+    else:
+        print("Wrong operator")
+
+jx_gui.win(code)     # Windows
+# jx_gui.lix(code)   # Linux
+```
+
+Write `jx_gui.win(code)`, not `jx_gui.win(code())`.
+
+## How it behaves
+
+- `print()` shows the text in the window.
+- `input("text")` shows the text above an input box. Press **Ok** (or Enter) to continue.
+- Any `print()` or `input()` that is inside an `if / elif / else` appears as a popup with an **Ok** button.
+- If your code crashes, the error is shown in the window and in a popup.
+
+## License
+
+MIT

jx_gui-1.0.0/src/jx_gui.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/jx_gui/__init__.py
+src/jx_gui/_core.py
+src/jx_gui/_linux.py
+src/jx_gui/_windows.py
+src/jx_gui.egg-info/PKG-INFO
+src/jx_gui.egg-info/SOURCES.txt
+src/jx_gui.egg-info/dependency_links.txt
+src/jx_gui.egg-info/top_level.txt

jx_gui-1.0.0/src/jx_gui.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jx_gui-1.0.0/src/jx_gui.egg-info/top_level.txt

@@ -0,0 +1 @@
+jx_gui