decterm 0.1.0__tar.gz

decterm-0.1.0/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.2
+Name: decterm
+Version: 0.1.0
+Summary: Cross-platform terminal controllable via Python (and web)
+Home-page: https://github.com/decrule/decterm
+Author: decterm
+Author-email: decrule@outlook.com
+License: MIT
+Keywords: terminal,shell,cross-platform,automation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Shells
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: requires-python
+
+# decterm
+
+Cross-platform terminal you can drive from Python. Run shell commands and get output, with or without a GUI.
+
+- **No GUI** (default): headless, ideal for scripts and servers.
+- **GUI mode**: live terminal window (tkinter) where you can type commands and see output.
+
+## Quick start
+
+```bash
+pip install decterm
+```
+
+```python
+from decterm import DecTerm
+
+# Headless
+dt = DecTerm()
+print(dt.send("dir"))       # or "ls" on Unix
+print(dt.sends("cd /tmp", "pwd"))
+dt.close()
+
+# With GUI
+dt = DecTerm(gui=True)
+dt.send("echo Hello")
+# Type commands in the window, then:
+dt.close()
+```
+
+## API (concise)
+
+| Method | Description |
+|--------|-------------|
+| `DecTerm(gui=False, cwd=None, env=None)` | Start a shell. `gui=True` opens a terminal window. |
+| `send(cmd, timeout=30)` | Run one command, return output. Times out for interactive programs (e.g. `python`). |
+| `sends(*cmds, timeout=30)` | Run several commands in order; returns last command’s output. |
+| `close()` | Stop the shell. |
+
+Use `timeout=None` in `send()` to wait indefinitely.
+
+## Requirements
+
+- Python 3.7+
+- Windows, macOS, or Linux  
+- No extra packages (uses only the standard library, including tkinter for GUI).
+
+## License
+
+MIT

decterm-0.1.0/README.md

@@ -0,0 +1,49 @@
+# decterm
+
+Cross-platform terminal you can drive from Python. Run shell commands and get output, with or without a GUI.
+
+- **No GUI** (default): headless, ideal for scripts and servers.
+- **GUI mode**: live terminal window (tkinter) where you can type commands and see output.
+
+## Quick start
+
+```bash
+pip install decterm
+```
+
+```python
+from decterm import DecTerm
+
+# Headless
+dt = DecTerm()
+print(dt.send("dir"))       # or "ls" on Unix
+print(dt.sends("cd /tmp", "pwd"))
+dt.close()
+
+# With GUI
+dt = DecTerm(gui=True)
+dt.send("echo Hello")
+# Type commands in the window, then:
+dt.close()
+```
+
+## API (concise)
+
+| Method | Description |
+|--------|-------------|
+| `DecTerm(gui=False, cwd=None, env=None)` | Start a shell. `gui=True` opens a terminal window. |
+| `send(cmd, timeout=30)` | Run one command, return output. Times out for interactive programs (e.g. `python`). |
+| `sends(*cmds, timeout=30)` | Run several commands in order; returns last command’s output. |
+| `close()` | Stop the shell. |
+
+Use `timeout=None` in `send()` to wait indefinitely.
+
+## Requirements
+
+- Python 3.7+
+- Windows, macOS, or Linux  
+- No extra packages (uses only the standard library, including tkinter for GUI).
+
+## License
+
+MIT

decterm-0.1.0/decterm/__init__.py

@@ -0,0 +1,16 @@
+"""
+decterm - Cross-platform terminal controllable via Python (and web).
+
+Usage:
+    from decterm import DecTerm
+
+    dt = DecTerm()
+    result = dt.send('dir')
+    result = dt.sends('cd e', 'mkdir aaaa')
+    dt.close()
+"""
+
+from decterm.terminal import DecTerm
+
+__all__ = ["DecTerm"]
+__version__ = "0.1.0"

decterm-0.1.0/decterm/terminal.py

@@ -0,0 +1,448 @@
+"""
+DecTerm - Cross-platform programmatic terminal session.
+
+Runs a persistent shell; on GUI systems a visible terminal could be shown,
+on headless systems (e.g. CentOS server) it runs without a window.
+"""
+
+import os
+import queue
+import re
+import sys
+import subprocess
+import threading
+
+# We append this to each command and read until we see it (avoids prompt parsing).
+_END_MARKER = "__DECTERM_END__"
+_END_MARKER_BYTES = _END_MARKER.encode("utf-8")
+
+
+def _is_windows():
+    return sys.platform == "win32"
+
+
+class DecTerm:
+    """
+    A persistent terminal session. Use send() / sends() to run commands,
+    close() to shut down the shell.
+    """
+
+    def __init__(self, gui=False, shell=None, cwd=None, env=None):
+        """
+        Start a terminal (shell process).
+
+        :param gui: If True, show a GUI window with live output and an input box to send commands.
+        :param shell: Optional path to shell (default: cmd on Windows, bash on Unix).
+        :param cwd: Working directory (default: current).
+        :param env: Environment dict (default: inherit from os.environ).
+        """
+        self._gui = gui
+        self._cwd = cwd or os.getcwd()
+        self._env = dict(env) if env is not None else dict(os.environ)
+        self._shell_cmd = shell
+        self._process = None
+        self._closed = False
+        self._result_for_send = None  # Queue for send() to get result in GUI mode
+        self._command_lock = threading.Lock()
+        self._display_queue = queue.Queue() if gui else None
+        self._command_done_event = threading.Event() if gui else None
+        self._gui_thread = None
+        self._skip_next_result = False  # discard next marker result (after timeout)
+        self._result_queue = None if gui else queue.Queue()  # non-GUI: reader puts here
+        self._reader_thread = None  # non-GUI reader
+        self._start()
+
+    def _start(self):
+        if _is_windows():
+            shell_cmd = self._shell_cmd or "cmd.exe"
+            creationflags = 0
+            if _is_windows() and not self._gui:
+                creationflags = getattr(subprocess, "CREATE_NO_WINDOW", 0x08000000)
+            self._process = subprocess.Popen(
+                [shell_cmd, "/Q", "/K"],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                cwd=self._cwd,
+                env=self._env,
+                creationflags=creationflags,
+            )
+            try:
+                self._process.stdin.write("chcp 65001 >nul\r\n".encode("utf-8"))
+                self._process.stdin.write("prompt \r\n".encode("utf-8"))
+                self._process.stdin.write(f"echo {_END_MARKER}\r\n".encode("utf-8"))
+                self._process.stdin.flush()
+            except Exception:
+                pass
+            self._read_until_marker(self._process.stdout)
+        else:
+            shell_cmd = self._shell_cmd or "/bin/bash"
+            self._process = subprocess.Popen(
+                [shell_cmd, "-i"],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                cwd=self._cwd,
+                env={**self._env, "PS1": ""},
+            )
+            self._process.stdin.write(f"echo {_END_MARKER}\n".encode("utf-8"))
+            self._process.stdin.flush()
+            self._read_until_marker(self._process.stdout)
+
+        if not self._gui and self._result_queue is not None:
+            self._reader_thread = threading.Thread(target=self._non_gui_reader_loop, daemon=True)
+            self._reader_thread.start()
+
+        if self._gui:
+            self._command_done_event.set()
+            self._reader_thread = threading.Thread(target=self._gui_reader_loop, daemon=True)
+            self._reader_thread.start()
+            self._gui_thread = threading.Thread(target=self._run_gui, daemon=True)
+            self._gui_thread.start()
+            # Let GUI and reader start
+            threading.Event().wait(0.3)
+
+    def _read_until_marker(self, stream):
+        """Read from stream until we see _END_MARKER. Returns collected text."""
+        buf = bytearray()
+        while True:
+            chunk = stream.read(1)
+            if not chunk:
+                break
+            buf.extend(chunk)
+            if len(buf) >= len(_END_MARKER_BYTES) and bytes(buf[-len(_END_MARKER_BYTES):]) == _END_MARKER_BYTES:
+                break
+            if _END_MARKER_BYTES in buf:
+                break
+        return buf.decode("utf-8", errors="replace")
+
+    @staticmethod
+    def _strip_output(out, raw_cmd=None):
+        """Strip marker line, path prompt, echoed command from output."""
+        lines = out.replace("\r", "").splitlines()
+        result_lines = []
+        for line in lines:
+            if _END_MARKER in line:
+                break
+            if raw_cmd and raw_cmd in line and _END_MARKER in line:
+                continue
+            if raw_cmd and line.strip() == raw_cmd:
+                continue
+            result_lines.append(line)
+        result = "\n".join(result_lines).strip()
+        result = re.sub(r"^[A-Za-z]:\\[^\r\n]*>", "", result, count=1)
+        if result.startswith(">") and (len(result) == 1 or result[1] != ">"):
+            result = result[1:].lstrip()
+        return result
+
+    def _non_gui_reader_loop(self):
+        """Background: read until marker, put stripped output to _result_queue. For non-GUI mode."""
+        stream = self._process.stdout
+        buf = bytearray()
+        while not self._closed and self._process and self._process.poll() is None:
+            try:
+                chunk = stream.read(1)
+            except (OSError, ValueError):
+                break
+            if not chunk:
+                break
+            buf.extend(chunk)
+            if _END_MARKER_BYTES not in buf:
+                continue
+            idx = buf.decode("utf-8", errors="replace").find(_END_MARKER)
+            if idx < 0:
+                continue
+            before = buf[:idx].decode("utf-8", errors="replace")
+            buf.clear()
+            result = self._strip_output(before)
+            try:
+                self._result_queue.put(result)
+            except Exception:
+                pass
+        try:
+            self._result_queue.put(None)
+        except Exception:
+            pass
+
+    def _gui_reader_loop(self):
+        """Read process stdout in GUI mode; push chunks to display_queue and result to _result_for_send."""
+        stream = self._process.stdout
+        buf = bytearray()
+        last_displayed = 0
+        while self._process and self._process.poll() is None and not self._closed:
+            try:
+                chunk = stream.read(1)
+            except (OSError, ValueError):
+                break
+            if not chunk:
+                break
+            buf.extend(chunk)
+            try:
+                s = buf.decode("utf-8", errors="replace")
+            except Exception:
+                continue
+            if _END_MARKER in s:
+                idx = s.find(_END_MARKER)
+                before = s[:idx]
+                to_show = before[last_displayed:].replace("\r", "")
+                if to_show:
+                    self._display_queue.put(to_show)
+                last_displayed = 0
+                buf.clear()
+                # Strip marker line and path prompt for result
+                lines = before.replace("\r", "").splitlines()
+                result_lines = [ln for ln in lines if _END_MARKER not in ln]
+                result = "\n".join(result_lines).strip()
+                result = re.sub(r"^[A-Za-z]:\\[^\r\n]*>", "", result, count=1)
+                if result.startswith(">") and (len(result) == 1 or result[1] != ">"):
+                    result = result[1:].lstrip()
+                if getattr(self, "_skip_next_result", False):
+                    self._skip_next_result = False
+                elif getattr(self, "_result_for_send", None) is not None:
+                    try:
+                        self._result_for_send.put(result)
+                    except Exception:
+                        pass
+                    self._result_for_send = None
+                self._command_done_event.set()
+            else:
+                new_part = s[last_displayed:].replace("\r", "")
+                if new_part:
+                    self._display_queue.put(new_part)
+                    last_displayed = len(s)
+        self._display_queue.put(None)  # EOF
+
+    def _run_gui(self):
+        """Run the tkinter terminal window (in a thread)."""
+        try:
+            import tkinter as tk
+            from tkinter import scrolledtext
+        except ImportError:
+            self._display_queue.put("[GUI requires tkinter]\n")
+            return
+        root = tk.Tk()
+        root.title("DecTerm")
+        root.geometry("860x520")
+        root.minsize(480, 320)
+
+        # 终端风格配色：深色背景 + 浅色字
+        bg_dark = "#0d1117"
+        bg_input = "#161b22"
+        fg_main = "#e6edf3"
+        fg_prompt = "#7ee787"  # 绿色提示符
+        border = "#30363d"
+        insert_bg = "#58a6ff"
+
+        root.configure(bg=bg_dark)
+
+        # 输出区：等宽字体、合适行距
+        out = scrolledtext.ScrolledText(
+            root,
+            wrap=tk.WORD,
+            font=("Consolas", 11),
+            state=tk.DISABLED,
+            bg=bg_dark,
+            fg=fg_main,
+            insertbackground=insert_bg,
+            selectbackground="#264f78",
+            selectforeground=fg_main,
+            relief=tk.FLAT,
+            padx=12,
+            pady=12,
+            borderwidth=0,
+        )
+        out.pack(fill=tk.BOTH, expand=True, padx=8, pady=(8, 0))
+        out.tag_configure("prompt", foreground=fg_prompt)
+        out.tag_configure("output", foreground=fg_main)
+
+        # 输入行：单独背景、绿色提示符
+        frame = tk.Frame(root, bg=bg_input, highlightbackground=border, highlightthickness=1)
+        frame.pack(fill=tk.X, padx=8, pady=8)
+        prompt_label = tk.Label(
+            frame, text="> ", font=("Consolas", 11), fg=fg_prompt, bg=bg_input
+        )
+        prompt_label.pack(side=tk.LEFT, padx=(12, 4), pady=10)
+        entry = tk.Entry(
+            frame,
+            font=("Consolas", 11),
+            bg=bg_dark,
+            fg=fg_main,
+            insertbackground=insert_bg,
+            relief=tk.FLAT,
+            highlightthickness=0,
+        )
+        entry.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=(0, 12), pady=10, ipady=6)
+
+        def append_output(text, tag=None):
+            if text is None:
+                return
+            out.config(state=tk.NORMAL)
+            if tag:
+                out.insert(tk.END, text, tag)
+            else:
+                out.insert(tk.END, text)
+            out.see(tk.END)
+            out.config(state=tk.DISABLED)
+
+        def pump_display():
+            try:
+                while True:
+                    msg = self._display_queue.get_nowait()
+                    append_output(msg)
+                    if msg is None:
+                        break
+            except queue.Empty:
+                pass
+            if not self._closed and self._process and self._process.poll() is None:
+                root.after(50, pump_display)
+            else:
+                try:
+                    while True:
+                        msg = self._display_queue.get(timeout=0.1)
+                        append_output(msg)
+                        if msg is None:
+                            break
+                except (queue.Empty, queue.Full):
+                    pass
+
+        def on_send():
+            cmd = entry.get().strip()
+            if not cmd:
+                return
+            entry.delete(0, tk.END)
+            append_output("\n> " + cmd + "\n", "prompt")
+            threading.Thread(target=_user_send, args=(cmd,), daemon=True).start()
+
+        def _user_send(cmd):
+            with self._command_lock:
+                self._command_done_event.clear()
+                if self._closed or self._process is None or self._process.poll() is not None:
+                    return
+                if _is_windows():
+                    full = f"{cmd} & echo {_END_MARKER}\r\n"
+                else:
+                    full = f"{cmd}; echo {_END_MARKER}\n"
+                try:
+                    self._process.stdin.write(full.encode("utf-8"))
+                    self._process.stdin.flush()
+                except Exception:
+                    pass
+            self._command_done_event.wait(timeout=60)
+
+        entry.bind("<Return>", lambda e: on_send())
+        entry.focus_set()
+        root.after(50, pump_display)
+
+        def on_closing():
+            self.close()
+            root.destroy()
+
+        root.protocol("WM_DELETE_WINDOW", on_closing)
+        try:
+            root.mainloop()
+        except Exception:
+            pass
+
+    def send(self, command, timeout=30):
+        """
+        Run one command in the terminal and return its output (stdout + stderr).
+
+        For interactive commands (e.g. python, bash) that never print the end marker,
+        send() will return after timeout seconds with a hint instead of blocking forever.
+
+        :param command: Command string (e.g. 'dir', 'ls -la').
+        :param timeout: Max seconds to wait for command output (default 30). Use None to wait forever.
+        :return: Output text of the command (string).
+        """
+        if self._closed or self._process is None or self._process.poll() is not None:
+            raise RuntimeError("DecTerm is closed or not running")
+        raw = command.strip()
+        _timeout = timeout if timeout is not None else 1e9
+
+        if self._gui:
+            if self._skip_next_result:
+                self._skip_next_result = False
+                self._result_for_send = None
+            result_queue = queue.Queue()
+            with self._command_lock:
+                self._result_for_send = result_queue
+                self._command_done_event.clear()
+                if self._display_queue is not None:
+                    self._display_queue.put("\n> " + raw + "\n")
+                if _is_windows():
+                    full_cmd = f"{raw} & echo {_END_MARKER}\r\n"
+                else:
+                    full_cmd = f"{raw}; echo {_END_MARKER}\n"
+                try:
+                    self._process.stdin.write(full_cmd.encode("utf-8"))
+                    self._process.stdin.flush()
+                except Exception:
+                    self._result_for_send = None
+                    return ""
+            try:
+                return result_queue.get(timeout=_timeout)
+            except queue.Empty:
+                self._skip_next_result = True
+                self._result_for_send = None
+                return "[DecTerm] Timeout - command may be interactive (e.g. python). Use GUI to interact or exit the subprocess."
+
+        # Non-GUI: discard stale result from previous timeout if any
+        if self._skip_next_result and self._result_queue is not None:
+            self._skip_next_result = False
+            try:
+                self._result_queue.get(timeout=0.5)
+            except queue.Empty:
+                pass
+        if _is_windows():
+            full_cmd = f"{raw} & echo {_END_MARKER}\r\n"
+        else:
+            full_cmd = f"{raw}; echo {_END_MARKER}\n"
+        try:
+            self._process.stdin.write(full_cmd.encode("utf-8"))
+            self._process.stdin.flush()
+        except Exception:
+            return ""
+        try:
+            result = self._result_queue.get(timeout=_timeout)
+        except queue.Empty:
+            self._skip_next_result = True
+            return "[DecTerm] Timeout - command may be interactive (e.g. python). Exit the subprocess (e.g. exit()) or use a longer timeout."
+        if result is None:
+            return ""
+        return result
+
+    def sends(self, *commands, timeout=30):
+        """
+        Run multiple commands in sequence in the same shell session.
+        Returns the output of the last command.
+
+        :param commands: One or more command strings.
+        :param timeout: Max seconds to wait per command (default 30). Passed to each send().
+        :return: Output of the last command (string).
+        """
+        result = None
+        for cmd in commands:
+            result = self.send(cmd, timeout=timeout)
+        return result
+
+    def close(self):
+        """Close the terminal and terminate the shell process."""
+        if self._closed:
+            return
+        self._closed = True
+        if self._process and self._process.poll() is None:
+            try:
+                self._process.terminate()
+                self._process.wait(timeout=3)
+            except (subprocess.TimeoutExpired, OSError):
+                try:
+                    self._process.kill()
+                except OSError:
+                    pass
+        self._process = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()

decterm-0.1.0/decterm.egg-info/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.2
+Name: decterm
+Version: 0.1.0
+Summary: Cross-platform terminal controllable via Python (and web)
+Home-page: https://github.com/decrule/decterm
+Author: decterm
+Author-email: decrule@outlook.com
+License: MIT
+Keywords: terminal,shell,cross-platform,automation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Shells
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: requires-python
+
+# decterm
+
+Cross-platform terminal you can drive from Python. Run shell commands and get output, with or without a GUI.
+
+- **No GUI** (default): headless, ideal for scripts and servers.
+- **GUI mode**: live terminal window (tkinter) where you can type commands and see output.
+
+## Quick start
+
+```bash
+pip install decterm
+```
+
+```python
+from decterm import DecTerm
+
+# Headless
+dt = DecTerm()
+print(dt.send("dir"))       # or "ls" on Unix
+print(dt.sends("cd /tmp", "pwd"))
+dt.close()
+
+# With GUI
+dt = DecTerm(gui=True)
+dt.send("echo Hello")
+# Type commands in the window, then:
+dt.close()
+```
+
+## API (concise)
+
+| Method | Description |
+|--------|-------------|
+| `DecTerm(gui=False, cwd=None, env=None)` | Start a shell. `gui=True` opens a terminal window. |
+| `send(cmd, timeout=30)` | Run one command, return output. Times out for interactive programs (e.g. `python`). |
+| `sends(*cmds, timeout=30)` | Run several commands in order; returns last command’s output. |
+| `close()` | Stop the shell. |
+
+Use `timeout=None` in `send()` to wait indefinitely.
+
+## Requirements
+
+- Python 3.7+
+- Windows, macOS, or Linux  
+- No extra packages (uses only the standard library, including tkinter for GUI).
+
+## License
+
+MIT

decterm-0.1.0/decterm.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+setup.py
+decterm/__init__.py
+decterm/terminal.py
+decterm.egg-info/PKG-INFO
+decterm.egg-info/SOURCES.txt
+decterm.egg-info/dependency_links.txt
+decterm.egg-info/requires.txt
+decterm.egg-info/top_level.txt

decterm-0.1.0/decterm.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

decterm-0.1.0/decterm.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[dev]
+pytest>=7.0

decterm-0.1.0/decterm.egg-info/top_level.txt

@@ -0,0 +1 @@
+decterm

decterm-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "decterm"
+version = "0.1.0"
+description = "Cross-platform terminal controllable via Python (and web)"
+readme = "README.md"
+requires-python = ">=3.7"
+license = { text = "MIT" }
+authors = [{ name = "decterm" }]
+keywords = ["terminal", "shell", "cross-platform", "automation"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: System :: Shells",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["decterm*"]

decterm-0.1.0/setup.cfg

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

decterm-0.1.0/setup.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""Setup script for decterm. Use: pip install .  or  python setup.py sdist bdist_wheel  then  twine upload dist/*"""
+
+import os
+from setuptools import find_packages, setup
+
+# Package metadata (edit these for your PyPI listing)
+NAME = "decterm"
+DESCRIPTION = "Cross-platform terminal controllable via Python (and web)"
+URL = "https://github.com/decrule/decterm"
+EMAIL = "decrule@outlook.com"
+AUTHOR = "DecRule"
+REQUIRES_PYTHON = ">=3.7"
+REQUIRED = []  # no runtime dependencies
+EXTRAS = {"dev": ["pytest>=7.0"]}
+
+# Version: prefer decterm.__version__, fallback to literal
+here = os.path.abspath(os.path.dirname(__file__))
+try:
+    import importlib.util
+    spec = importlib.util.spec_from_file_location("_decterm_version", os.path.join(here, "decterm", "__init__.py"))
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    VERSION = getattr(mod, "__version__", "0.1.0")
+except Exception:
+    VERSION = "0.1.0"
+
+try:
+    with open(os.path.join(here, "README.md"), encoding="utf-8") as f:
+        long_description = f.read()
+except FileNotFoundError:
+    long_description = DESCRIPTION
+
+setup(
+    name=NAME,
+    version=VERSION,
+    description=DESCRIPTION,
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author=AUTHOR,
+    author_email=EMAIL,
+    url=URL,
+    python_requires=REQUIRES_PYTHON,
+    packages=find_packages(exclude=["tests", "*.tests", "*.tests.*", "tests.*"]),
+    install_requires=REQUIRED,
+    extras_require=EXTRAS,
+    include_package_data=True,
+    license="MIT",
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Topic :: System :: Shells",
+    ],
+)