commiefetch 1.2.0__tar.gz → 1.2.2__tar.gz

{commiefetch-1.2.0/src/commiefetch.egg-info → commiefetch-1.2.2}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: commiefetch
-Version: 1.2.0
+Version: 1.2.2
 Summary: Communist-themed system information tool — like neofetch, but red
 Author: commiefetch contributors
-License-Expression: MIT
+License-Expression: GPL-3.0-only
 Project-URL: Source, https://github.com/amalxloop/commiefetch
 Project-URL: Tracker, https://github.com/amalxloop/commiefetch/issues
 Keywords: system-info,neofetch,communist,fastfetch,cli

{commiefetch-1.2.0 → commiefetch-1.2.2}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "commiefetch"
-version = "1.2.0"
+version = "1.2.2"
 description = "Communist-themed system information tool — like neofetch, but red"
 readme = "README.md"
 authors = [
     {name = "commiefetch contributors"},
 ]
-license = "MIT"
+license = "GPL-3.0-only"
 requires-python = ">=3.8"
 keywords = ["system-info", "neofetch", "communist", "fastfetch", "cli"]
 classifiers = [

{commiefetch-1.2.0 → commiefetch-1.2.2}/src/commiefetch/__init__.py

@@ -1,2 +1,2 @@
-__version__ = "1.2.0"
+__version__ = "1.2.2"
 __app_name__ = "commiefetch"

{commiefetch-1.2.0 → commiefetch-1.2.2}/src/commiefetch/cli.py

@@ -187,7 +187,10 @@ def get_module_value(name):
     }
     func = mappers.get(name)
     if func:
-        return func()
+        try:
+            return func()
+        except Exception:
+            return None
     return None
 
 
@@ -195,7 +198,12 @@ def _format_memory(mem):
     if not mem:
         return "unknown"
     if isinstance(mem, dict):
-        return f"{mem.get('used', 0)} {mem.get('unit', 'MiB')} / {mem.get('total', 0)} {mem.get('unit', 'MiB')} ({mem.get('percent', 0)}%)"
+        total = mem.get('total', 0)
+        used = mem.get('used', 0)
+        pct = mem.get('percent', 0)
+        if total >= 1024:
+            return f"{used/1024:.1f} GiB / {total/1024:.1f} GiB ({pct}%)"
+        return f"{used} MiB / {total} MiB ({pct}%)"
     return str(mem)
 
 

{commiefetch-1.2.0 → commiefetch-1.2.2}/src/commiefetch/modules.py

@@ -7,13 +7,22 @@ import shutil
 import socket
 import pwd
 import grp
+import struct
 from pathlib import Path
 
 from .colors import NO_COLOR
 
 
 def is_termux():
-    return bool(os.environ.get("TERMUX_VERSION")) or "/com.termux/" in __file__
+    if bool(os.environ.get("TERMUX_VERSION")):
+        return True
+    if "/com.termux/" in __file__:
+        return True
+    if os.environ.get("PREFIX", "").startswith("/data/data/com.termux"):
+        return True
+    if os.path.exists("/data/data/com.termux/files/usr/bin/termux-setup-package"):
+        return True
+    return False
 
 _cache = {}
 _cache_time = {}
@@ -328,23 +337,168 @@ def get_gpu():
         return "unknown"
 
 
+def _get_dumpsys_memory():
+    """Parse 'dumpsys meminfo' output on Android."""
+    try:
+        out = run_cmd(["dumpsys", "meminfo"], timeout=5)
+        if not out:
+            out = run_cmd(["/system/bin/dumpsys", "meminfo"], timeout=5)
+        if not out:
+            return None
+        for line in out.split("\n"):
+            line = line.strip()
+            if "Total RAM:" in line:
+                val = line.split(":")[-1].strip()
+                val = val.replace(",", "").replace(" ", "")
+                if val.endswith("kB"):
+                    total_mb = int(val[:-2]) // 1024
+                elif val.endswith("MB"):
+                    total_mb = int(val[:-2])
+                elif val.endswith("GB"):
+                    total_mb = int(float(val[:-2]) * 1024)
+                else:
+                    total_mb = int(val) // 1024
+                return {"total": total_mb, "used": 0, "available": 0,
+                        "unit": "MiB", "percent": 0}
+        return None
+    except Exception:
+        return None
+
+
+def _get_sysinfo_memory():
+    try:
+        import ctypes
+        import platform as _plat
+        libc = None
+        for name in ["libc.so.6", "libc.so"]:
+            try:
+                libc = ctypes.CDLL(name)
+                break
+            except OSError:
+                continue
+        if libc is None:
+            return None
+
+        buf = ctypes.create_string_buffer(200)
+        ret = libc.sysinfo(buf)
+        if ret != 0:
+            return None
+        data = buf.raw
+
+        is_64 = _plat.machine() in ("aarch64", "x86_64", "amd64")
+        if is_64:
+            fmt = "<q3Q7QH2QI"
+        else:
+            fmt = "<i3I7IH2II8x"
+
+        fields = struct.unpack_from(fmt, data)
+        mem_unit = fields[-1] or 1
+        totalram = fields[3]
+        freeram = fields[4]
+        total_mb = totalram * mem_unit // (1024 * 1024)
+        if total_mb == 0:
+            return None
+        free_mb = freeram * mem_unit // (1024 * 1024)
+        used_mb = total_mb - free_mb
+        return {
+            "total": total_mb,
+            "used": used_mb,
+            "available": free_mb,
+            "unit": "MiB",
+            "percent": round(used_mb / total_mb * 100, 1) if total_mb else 0,
+        }
+    except Exception:
+        return None
+
+
+def _parse_meminfo_value(val):
+    val = val.strip().replace(",", "")
+    if val.endswith(" kB"):
+        return int(val.split()[0]) // 1024
+    if val.endswith(" MB"):
+        return int(val.split()[0])
+    if val.endswith(" GB"):
+        return int(float(val.split()[0]) * 1024)
+    if val.endswith(" KB"):
+        return int(val.split()[0]) // 1024
+    if val.endswith(" mb"):
+        return int(val.split()[0])
+    if val.endswith(" gb"):
+        return int(float(val.split()[0]) * 1024)
+    try:
+        return int(val)
+    except ValueError:
+        try:
+            return int(float(val))
+        except ValueError:
+            return 0
+
+
 @cached("memory", 5)
 def get_memory():
     try:
         system = platform.system()
         if system == "Linux":
-            with open("/proc/meminfo") as f:
-                meminfo = {}
-                for line in f:
+            meminfo = {}
+            raw = None
+            try:
+                with open("/proc/meminfo") as f:
+                    raw = f.read()
+            except Exception:
+                raw = run_cmd(["cat", "/proc/meminfo"], timeout=3)
+            if raw:
+                for line in raw.split("\n"):
                     parts = line.split(":")
                     if len(parts) == 2:
-                        val = parts[1].strip()
-                        if val.endswith(" kB"):
-                            val = int(val.split()[0]) // 1024
-                        meminfo[parts[0]] = val
+                        meminfo[parts[0]] = _parse_meminfo_value(parts[1])
             total = meminfo.get("MemTotal", 0)
+            if not isinstance(total, (int, float)) or total <= 0:
+                total = 0
+            if total == 0:
+                result = _get_sysinfo_memory()
+                if result and result.get("total", 0) > 0:
+                    return result
+                result = _get_dumpsys_memory()
+                if result and result.get("total", 0) > 0:
+                    return result
+                free_out = run_cmd(["free", "-m"], timeout=3)
+                if free_out:
+                    for line in free_out.split("\n"):
+                        if line.startswith("Mem:"):
+                            cols = line.split()
+                            if len(cols) >= 3:
+                                try:
+                                    t = int(cols[1])
+                                    if t > 0:
+                                        u = int(cols[2])
+                                        return {
+                                            "total": t, "used": u,
+                                            "available": t - u, "unit": "MiB",
+                                            "percent": round(u / t * 100, 1),
+                                        }
+                                except Exception:
+                                    pass
+                return None
             avail = meminfo.get("MemAvailable", 0)
+            if not isinstance(avail, (int, float)):
+                avail = 0
+            if avail == 0:
+                free = meminfo.get("MemFree", 0)
+                buffers = meminfo.get("Buffers", 0)
+                cached = meminfo.get("Cached", 0)
+                slab = meminfo.get("SReclaimable", 0)
+                if not isinstance(free, (int, float)):
+                    free = 0
+                if not isinstance(buffers, (int, float)):
+                    buffers = 0
+                if not isinstance(cached, (int, float)):
+                    cached = 0
+                if not isinstance(slab, (int, float)):
+                    slab = 0
+                avail = free + buffers + cached + slab
             used = total - avail
+            if used < 0:
+                used = 0
             return {
                 "total": total,
                 "used": used,
@@ -417,10 +571,10 @@ def get_memory():
                     "unit": "MiB",
                     "percent": round(used_mb / total_mb * 100, 1) if total_mb else 0,
                 }
-            return {"total": total, "used": 0, "unit": "MiB", "percent": 0}
-        return {"total": 0, "used": 0, "unit": "MiB", "percent": 0}
+            return None
+        return None
     except Exception:
-        return {"total": 0, "used": 0, "unit": "MiB", "percent": 0}
+        return None
 
 
 @cached("swap", 30)
@@ -456,7 +610,7 @@ def get_disk(path="/"):
         total = usage.total // (1024 * 1024)
         used = usage.used // (1024 * 1024)
         free = usage.free // (1024 * 1024)
-        return {
+        info = {
             "total": total,
             "used": used,
             "free": free,
@@ -464,7 +618,45 @@ def get_disk(path="/"):
             "mount": path,
             "percent": round(used / total * 100, 1) if total else 0,
         }
+        if is_termux():
+            for p in ["/storage/emulated/0", "/sdcard", "/data/media/0"]:
+                try:
+                    u2 = shutil.disk_usage(p)
+                    t2 = u2.total // (1024 * 1024)
+                    if t2 > info["total"]:
+                        info = {
+                            "total": t2,
+                            "used": u2.used // (1024 * 1024),
+                            "free": u2.free // (1024 * 1024),
+                            "unit": "MiB",
+                            "mount": p,
+                            "percent": round(u2.used // (1024 * 1024) / t2 * 100, 1) if t2 else 0,
+                        }
+                except Exception:
+                    pass
+        return info
     except Exception:
+        if is_termux():
+            for p in [path, "/storage/emulated/0", "/sdcard", "/data/media/0"]:
+                out = run_cmd(["df", "-m", p], timeout=5)
+                if out:
+                    for line in out.split("\n"):
+                        parts = line.split()
+                        if len(parts) >= 6 and parts[-1] == p:
+                            try:
+                                total = int(parts[1])
+                                if total > 0:
+                                    used = int(parts[2])
+                                    return {
+                                        "total": total,
+                                        "used": used,
+                                        "free": total - used,
+                                        "unit": "MiB",
+                                        "mount": p,
+                                        "percent": round(used / total * 100, 1) if total else 0,
+                                    }
+                            except Exception:
+                                pass
         return None
 
 
@@ -487,6 +679,24 @@ def get_disks():
                                     "mount": mount,
                                     "info": info,
                                 })
+            if not disks and is_termux():
+                root = get_disk("/")
+                if root and root["total"] >= 1024:
+                    disks.append({
+                        "device": "rootfs",
+                        "mount": "/",
+                        "info": root,
+                    })
+                for p in ["/storage/emulated/0", "/sdcard", "/data/media/0"]:
+                    info = get_disk(p)
+                    if info and info["total"] >= 1024:
+                        seen = any(d["mount"] == p for d in disks)
+                        if not seen:
+                            disks.append({
+                                "device": "internal",
+                                "mount": p,
+                                "info": info,
+                            })
             return disks[:4]
         except Exception:
             pass
@@ -578,6 +788,15 @@ def get_desktop():
 def get_packages():
     system = platform.system()
     count = 0
+    if is_termux():
+        out = run_cmd(["dpkg", "--list"], timeout=5)
+        if out:
+            count = len([l for l in out.split("\n") if l.startswith("ii")])
+        if not count:
+            out = run_cmd(["apt", "list", "--installed", "2>/dev/null"], timeout=5)
+            if out:
+                count = len([l for l in out.split("\n") if "/" in l])
+        return count or 0
     if system == "Linux":
         methods = [
             (["dpkg", "--list"], lambda l: len(l.split("\n")) - 5),

{commiefetch-1.2.0 → commiefetch-1.2.2/src/commiefetch.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: commiefetch
-Version: 1.2.0
+Version: 1.2.2
 Summary: Communist-themed system information tool — like neofetch, but red
 Author: commiefetch contributors
-License-Expression: MIT
+License-Expression: GPL-3.0-only
 Project-URL: Source, https://github.com/amalxloop/commiefetch
 Project-URL: Tracker, https://github.com/amalxloop/commiefetch/issues
 Keywords: system-info,neofetch,communist,fastfetch,cli