pmemstat 2.3.28__tar.gz → 2.3.29__tar.gz

pmemstat-2.3.29/.gitignore

@@ -0,0 +1,5 @@
+pmemstat.bundle
+dist/
+__pycache__/
+.vscode/
+*.egg-info/

{pmemstat-2.3.28/src/pmemstat.egg-info → pmemstat-2.3.29}/PKG-INFO

@@ -1,19 +1,18 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pmemstat
-Version: 2.3.28
+Version: 2.3.29
 Summary: Report Proportional Memory on Linux
-Author-email: Joe Defen <joedef@duck.com>
-License: MIT
-Project-URL: Homepage, https://github.com/joedefen/pmemstat
-Project-URL: Bug Tracker, https://github.com/joedefen/pmemstat/issues
 Keywords: proportional memory,RAM,htop,top,monitor
+Author-email: Joe Defen <joedef@duck.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: POSIX :: Linux
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: psutil>5.9
+Project-URL: Bug Tracker, https://github.com/joedefen/pmemstat/issues
+Project-URL: Homepage, https://github.com/joedefen/pmemstat
 
 > **Quick Start**: from the CLI
 > * **If `python3 -V` shows v3.11 or later, install with `pipx`**:

pmemstat-2.3.29/deploy

@@ -0,0 +1,8 @@
+#!/bin/bash
+script_dir=$(dirname "$0")
+set -ex
+cd ${script_dir}
+rm -rf ./dist
+python3 -m pip install build --break-system-packages
+python3 -m build
+pip install -e . --break-system-packages

pmemstat-2.3.29/memtest.c

@@ -0,0 +1,215 @@
+// A test program for 'pmemstat' which grows its memory over time including:
+//    - stack
+//    - heap (TODO)
+//    - SysV shared memory
+//    - memory mapped files (TODO)
+// Several instances of the this programs can be run, and, if so, the
+// programs will share the SysV shared memory and the memory mapped files.
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <sys/sem.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+
+#define CNT 128 /* how big can things get */
+#define CHUNK_SIZE ((size_t)(10*1024))  /* make it a 10K shared memory segment */
+#define BASE_KEY 0xffeeddcc
+#define DIM(A) (sizeof(A)/sizeof(A[0]))
+#define FILENAME "/tmp/memmapfile"
+
+int rm_shmem();
+int rm_mmap();
+
+struct Args {
+    int sleep_sec; // delay per loop
+    int n_loops; // number of loops
+} Args = {.sleep_sec = 10, .n_loops = CNT};
+
+struct MyData {
+    int n_shmem; void *shmemp[CNT];
+    int n_malloc; void *mallocp[CNT];
+    int n_mmap; int mm_fd; unsigned char *mm_ptr;
+} MyData;
+
+int LoopCnt = 0;
+
+int incr_sem() {
+    // returns the count of these processes (so the first can initialize)
+    int semid, val0, val1;
+    int key = BASE_KEY;
+    if ((semid = semget(key, 2, 0644 | IPC_CREAT)) == -1) {
+        perror("shmget");
+        exit(1);
+    }
+    struct sembuf sembufs[2] = {
+          { .sem_num = 0, .sem_op = 1, .sem_flg = SEM_UNDO}
+        , { .sem_num = 1, .sem_op = 1, .sem_flg = 0}
+    };
+    semop(semid, &sembufs[0], 1);
+    val0 = semctl(semid, 0, GETVAL);
+    printf("semval=%d\n", val0);
+
+    for (bool done = false; !done; ) {
+        if (val0 == 1) {
+            rm_shmem();
+            rm_mmap();
+            semop(semid, &sembufs[1], 1);
+            done = true;
+        } else {
+            for (int loop = 0, val1 = 0; val1 != 1; loop++) {
+                val1 = semctl(semid, 1, GETVAL);
+                if (val1 >= 0) {
+                    done = true;
+                    break;
+                } else if (loop >= val0) {
+                    printf("%d gave up on init; forcing it, loop=%d", val0, loop);
+                    val0 = 1;
+                    break;
+                } else {
+                    sleep(1);
+                    printf("%d waiting on val1==0, got %d, loop %d\n", val0, val1, loop);
+                }
+            }
+        }
+    }
+    return val0;
+}
+
+    
+//////////////////////////////// SHMEM
+
+int add_shmem() {
+    int idx = MyData.n_shmem;
+    if (idx >= CNT) {
+        printf("add_shmem: too many shmemp\n");
+        exit(1);
+    }
+    key_t key = BASE_KEY + idx;
+    int shmid;
+    char *data;
+    /*  create/attach the segment: */
+    if ((shmid = shmget(key, CHUNK_SIZE, 0644 | IPC_CREAT)) == -1) {
+        perror("shmget");
+        exit(1);
+    }
+    /* attach to the segment to get a pointer to it: */
+    data = shmat(shmid, NULL, 0);
+    if (data == (char *)(-1)) {
+        perror("shmat");
+        exit(1);
+    }
+    MyData.shmemp[idx] = data;
+    idx += 1;
+    MyData.n_shmem = idx;
+    memset(data, 'a', CHUNK_SIZE);
+    // printf("add_shmem: bytes=%luK\n", (idx*CHUNK_SIZE)/1024);
+}
+
+int rm_shmem() {
+    int shmid;
+    int removed = 0;
+    for (int idx = 0; idx < CNT; idx++) {
+        key_t key = BASE_KEY + idx;
+        if ((shmid = shmget(key, CHUNK_SIZE, 0)) == -1)
+            continue;
+        if (shmctl(shmid, IPC_RMID, NULL) >= 0)
+            removed += 1;
+    }
+    printf("removed %d segments\n", removed);
+}
+
+
+//////////////////////////////// MMAP
+
+int add_mmap() {
+    int fd;
+    unsigned char *ptr;
+    if ((fd = MyData.mm_fd) == 0) {
+        fd = open(FILENAME, O_RDWR|O_CREAT, 0666);
+        if (fd < 0) {
+            perror("open(/tmp/...)");
+            exit(1);
+        }
+        MyData.mm_fd = fd;
+        int rv = posix_fallocate(fd, 0, CNT*CHUNK_SIZE);
+        if (rv < 0) {
+            perror("posix_fallocate()");
+            exit(1);
+        }
+    }
+    if ((ptr = MyData.mm_ptr) == NULL) {
+        ptr = mmap(NULL, CNT*CHUNK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
+        if ((long) ptr == -1) {
+            perror("mmap()");
+            exit(1);
+        }
+        MyData.mm_ptr = ptr;
+    }
+    unsigned char* bottom = &ptr[MyData.n_mmap*CHUNK_SIZE];
+    memset(bottom, 'm', CHUNK_SIZE);
+    MyData.n_mmap += 1;
+    // printf("add_mmap: bytes=%luK\n", MyData.n_mmap*CHUNK_SIZE/1024);
+}
+
+int rm_mmap() {
+    unlink(FILENAME);
+}
+
+//////////////////////////////// MALLOC
+
+int add_malloc() {
+    MyData.mallocp[MyData.n_malloc] = malloc(CHUNK_SIZE);
+    MyData.n_malloc += 1;
+    // printf("add_malloc: bytes=%luK\n", MyData.n_malloc*CHUNK_SIZE/1024);
+}
+
+//////////////////////////////// MAIN LOOP STUFF
+
+int loop() {
+    void* heap = malloc(CHUNK_SIZE);
+    memset(heap, 'h', CHUNK_SIZE);
+    char stack[CHUNK_SIZE];
+    memset(stack, 'h', CHUNK_SIZE);
+    add_shmem();
+    add_mmap();
+    add_malloc();
+    printf("%d: loop=%d, shmem=%luK mmap=%luK stack=%luK heap=%luK\n",
+            getpid(),
+            LoopCnt+1,
+            MyData.n_shmem*CHUNK_SIZE/1024,
+            MyData.n_mmap*CHUNK_SIZE/1024,
+            MyData.n_mmap*CHUNK_SIZE/1024,
+            MyData.n_malloc*CHUNK_SIZE/1024);
+    sleep(Args.sleep_sec);
+    if (++LoopCnt >= Args.n_loops) {
+        exit(0);
+    }
+    loop(); // NOTE: recurses (to be able to add stack)
+}
+
+
+int main(int argc, char *argv[])
+{
+    int opt;
+    while ((opt = getopt(argc, argv, "qs")) != -1) {
+        switch(opt) {
+            case 'q': Args.sleep_sec = 1; break;
+            case 's': Args.n_loops = 16; break;
+            default:
+                printf("USE: %s {-qs} # quick,short", argv[0]);
+                exit(1);
+        }
+    }
+    memset(&MyData, 0, sizeof(MyData));
+    incr_sem();
+    loop();
+
+    return 0;
+}

pmemstat-2.3.29/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["flit_core>=3.4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "pmemstat"
+version = "2.3.29"
+description = "Report Proportional Memory on Linux"
+authors = [
+    {name = "Joe Defen", email = "joedef@duck.com"},
+]
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.8"
+keywords = ["proportional memory", "RAM", "htop", "top", "monitor"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX :: Linux"
+]
+dependencies = [
+    'psutil>5.9',
+]
+
+[project.urls]
+"Homepage" = "https://github.com/joedefen/pmemstat"
+"Bug Tracker" = "https://github.com/joedefen/pmemstat/issues"
+
+[project.scripts]
+pmemstat = "pmemstat.main:run"

pmemstat-2.3.29/run.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+SRC="$(dirname "$0")/src"
+
+set -x
+##### choose one:
+
+PYTHONPATH="$SRC" python3 -m pmemstat.main "$@"
+# PYTHONPATH="$SRC" python3 src/pmemstat/main.py "$@"

pmemstat-2.3.28/PKG-INFO

@@ -1,202 +0,0 @@
-Metadata-Version: 2.1
-Name: pmemstat
-Version: 2.3.28
-Summary: Report Proportional Memory on Linux
-Author-email: Joe Defen <joedef@duck.com>
-License: MIT
-Project-URL: Homepage, https://github.com/joedefen/pmemstat
-Project-URL: Bug Tracker, https://github.com/joedefen/pmemstat/issues
-Keywords: proportional memory,RAM,htop,top,monitor
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: POSIX :: Linux
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE.txt
-Requires-Dist: psutil>5.9
-
-> **Quick Start**: from the CLI
-> * **If `python3 -V` shows v3.11 or later, install with `pipx`**:
->   * install `pipx` per your distro's guidance
->   * then: `pipx upgrade pmemstat || pipx install pmemstat`
-> * **Else for python3.10 and lesser versions, install with `pip`**:
->   * install `pip` per your distro's guidance
->   * then: `python3 -m pip install --user --upgrade pmemstat`
-> * **To run**:
->   * simply run: `pmemstat`
->   * type "?" within `pmemstat` to show help screen.
-
-
-# pmemstat - Proportional Memory Status
-
-`pmemstat` shows detailed **proportional** memory use of **Linux** processes by digesting:
-* `/proc/{PID}/smaps`
-* `/proc/{PID}/smaps_rollup`
-
-Computing proportional memory avoids overstating memory use as many programs do (e.g., `top`). Specifically, proportional memory splits the cost of common memory to the processes sharing it (rather than counting common memory multiple times). And, it does not include uninstantiated virtual memory. 
-
-Without `-o`, `pmemstat` shows less details and is much faster and sometimes less accurate (e.g., it will not report classes of memory such as SysV shared memory which are often are not present anyhow). With `-o` providing full detail, digging out the numbers is slower; thus, `pmemstat -o` may take a few seconds to start, but, in its loop mode, refreshes are relatively fast and efficient by avoiding recomputing unchanged numbers. When in its window mode, typing `o` toggles low/high detail.
-
-`pmemstat`'s grouping feature rolls up the resources of multiple processes of a feature (e.g., a browser) to make the total memory/cpu impact much more apparent.
-
-Its looping features allow monitoring for changes in memory growth which may be "leaks".  Segregating memory by types can make identifying leaks faster and more certain.
-
-**In version 2.0, `pmemstat` has many new features including**:
-* In its **window mode**, `pmemstat` updates the terminal in place (using "curses") rather than scrolling.
-* Showing **CPU use**, too, which makes `pmemstat` a viable alternative to `top` for regular use (although more specialized and still focused on accurate memory representation).
-* Supports **killing processes** that are selected visually with confirmation they are really gone (or not).
-* And several **new options** that can be **controlled dynamically** if in window mode.
-
-## Installation Options
-Note that:
-* `pmemstat` needs to run as root to read the memory statistics for all processes (which is normally desired).
-* By default, `pmemstat` reruns itself as with `sudo` (thus you need `sudo` privileges).
-* To defeat re-running with `sudo`, use the `--run-as-user` or `-U` option.
-
-See the Quick Start at the top for preferred install instructions using `pipx`. If not acceptable, see the "Alternative Installation Options" section below.
-
-
-## Usage
-```
-usage: pmemstat [-h] [-D] [-C] [-g {exe,cmd,pid}] [-f] [-k MIN_DELTA_KB]
-        [-l LOOP_SECS] [-L CMDLEN] [-t TOP_PCT] [-n] [-U] [-o]
-        [-u {MB,mB,KB,human}] [-R] [-s {mem,cpu,name}] [-/ SEARCH] [-W] [pids ...]
-
-positional arguments:
-  pids                  list of pids/groups (none means every accessible pid)
-
-options:
-  -h, --help            show this help message and exit
-  -D, --debug           debug mode (the more Ds, the higher the debug level)
-  -C, --no-cpu          do NOT report percent CPU (only in window mode)
-  -g {exe,cmd,pid}, --groupby {exe,cmd,pid}
-                        grouping method for presenting rows
-  -f, --fit-to-window   do not overflow window [if -w]
-  -k MIN_DELTA_KB, --min-delta-kb MIN_DELTA_KB
-                        minimum delta KB to show again [dflt=100 if DB else 1000
-  -l LOOP_SECS, --loop LOOP_SECS
-                        loop interval in secs [dflt=5 if -w else 0]
-  -L CMDLEN, --cmdlen CMDLEN
-                        max shown command length [dflt=36 if not -w]
-  -t TOP_PCT, --top-pct TOP_PCT
-                        report group contributing to top pct of ptotal [dflt=100]
-  -n, --numbers         show line numbers in report
-  -U, --run-as-user     run as user (NOT as root)
-  -o, --others          collapse shSYSV, shOth, stack, text into "other"
-  -u {MB,mB,KB,human}, --units {MB,mB,KB,human}
-                        units of memory [dflt=MB]
-  -R, --no-rise         do NOT raise change/adds to top (only in window mode)
-  -s {mem,cpu,name}, --sortby {mem,cpu,name}
-                        grouping method for presenting rows
-  -/ SEARCH, --search SEARCH
-                        show items with search string in name
-  -W, --no-window       show in "curses" window [disables: -D,-t,-L]
-
-```
-Explanation of some options and arguments:
-* `-g {exe,cmd,pid}, --groupby {exe,cmd,pid}` -  select the grouping of memory stats for reporting.
-    * `exe` - group by basename of the executable (the default)
-    * `cmd` - group by the truncated command line (use `-L CMDLEN` to choose length)
-    * `pid` - group by one process
-* `-k MIN_DELTA_KB, --min-delta-kb MIN_DELTA_KB` - when looping, how much change in memory use is required to show the grouping in subsequent loops; note:
-    * a positive `MIN_DELTA_KB` means the total memory of the groupin must **grow** by that amount (in KB)
-    * a non-positive `MIN_DELTA_KB` means the total memory of the grouping must **change** by that amount (in KB)
-* `pids` - the positional arguments may be pids (i.e., numbers) or the names of executables (as shown by `-gexe`) 
-
-
-## Example Usage with Explanation of Output
-![pmemstat](https://github.com/joedefen/pmemstat/blob/main/images/pmemstat.png?raw=true)
-
-In the default refreshed window loop, we see
-* a **leader line** with:
-    * the current time
-    * from `/proc/meminfo` in MemTotal (Tot), MemAvailable (Avail), Tmp (Shmem+TmpFS), and Dirty.
-    * 'Oth' is the unaccounted for memory belonging to the kernel, reserve,
-       drivers, imprecision, etc.; `Oth = Tot - Avail - Tmp - ptotal`.
-       * Features such as BTRFS, ZFS, zRAM, unattached SysV Shared Memory, etc., can cause 'Oth' to be significant;
-         that is, MemAvail is often greatly understated (and 'Oth' is overstated).  As a test (not intended for regular use), try:
-         `sudo sync; sudo sh -c "echo 3 > /proc/sys/vm/drop_caches"`; if that reduces `Oth` significantly,
-         then the MemAvailable calculation was off significantly.
-       * Determining the contributors can be difficult, but start with `sudo slabtop -sc` and feature specific tools (e.g., `zpool list`).
-    * how many PIDs are contributing to the report vs the total number of PIDs excluding kernel threads
-* a **second leader line for zRAM** only if zRAM is active with:
-    * percent cpu consumed by kernel processes (not normalized ... if there 4 CPUs, then the total CPU can 400%). This is important because, with zRAM, this often is mostly the swap process.
-    * **zRAM** - the amount of "Used" RAM that is storing zRAM data
-    * **eTot** - the effective Total RAM and the percent of "Tot" RAM (which would typically be above 100%). The bigger **zRAM**, the more accurate this number.
-    * **eUsed** - the effective Used RAM and percent of "Tot" RAM.
-    * **eAvail** - the effective Available RAM and percent of "Tot" RAM.
-* a **header line with the reported fields** including:
-    * **cpu** - percent CPU (again not normalized to 100%)
-    * **pswap** - proportional use of swap (per smaps_rollup)
-    * **other** - partly sums these categories (shown by the key, `o`):
-      * **shSYSV** - proportional use of System V shared memory (per smaps)
-      * **shOth** - proportional use of other shared memory (per smaps)
-      * **stack** - exclusive use of stack memory per smaps
-      * **text** - proportional use of memory for text (i.e., the read-only binary code, per smaps)
-    * **data** - exclusive use of memory for data (i.e., exclusively used of "heap" memory, per smaps)
-    * **ptotal** - proportional use of memory of all categories (i.e, sum of columns to the left); **note**, if zRAM, this includes **pswap**, else not.
-    * *empty* - type of the entry which may be:
-        * **T** - the grand total
-        * **A** - a newly added grouping
-        * **O** - combined overflow groupings below the `--top-pct` threshold (only on first loop)
-        * **+-{number}K** - number of KB of change in **ptotal** (only on subsequent loops)
-    * **key/info** which is a quantifier plus the grouping key. The quantifier may be:
-        * **{PID}** - when the grouping line represents one process (for option `-gexe`).
-        * **{num}x** - where {num} is the number of processes in the grouping.
-        
-## Help Screen (in Window Mode, Press '?')
-In window mode, press '?' to enter the help screen which looks like:
-
-![helpscreen example](https://github.com/joedefen/pmemstat/blob/main/images/help-screen.png?raw=true)
-
-**Notes:**
-* There are a number of navigation keys (mostly following vim conventions); in the help screen, they apply to help screen; otherwise, they apply to main screen.
-* Below the line, there are a number of keys/options; when you type an option key (e.g, "c"), it will highlight the next option value (e.g., "off"); when you change options, they will be applied to the next loop of the main menu.
-    * These option keys can be used in the main menu (e.g., pressing "c" will change hide or reveal the CPU column w/o entering the help screen).
-    
-## Kill Mode (Window Mode)
-Pressing "K" enter "Kill Mode" where you use the navigation keys to highlight a row, and then press ENTER to kill the process(es) represented by that row.
-
-## Scroll Position (Window Mode)
-
-Sometimes, the horizontal line between the header and scrollable region has a reverse video block (under the "351" in this case):
-![scroll-pos example](https://github.com/joedefen/pmemstat/blob/main/images/scroll-pos.png?raw=true)
-
-**Notes:**
-* When there is no block, the scrolled document does not overflow the scrollable region.
-* When there is a block, its position indicates:
-    * **Leftmost** - At the top of the document.
-    * **Rightmost** - At the bottom of the document.
-    * **Between Leftmost and Rightmost** - At percentage of the document approximated by its position from Left (0%) to Right (100%).
-* Its length indicates, roughly, how much of the entire document you can see.
-* Again, you can press 'f' to fit the document to the screen with a "rollup" line summarizing the lines that would not fit.
-
-## Quirks and Details
-* **pswap** seems to be only provided by the `smaps_rollups` file, and thus it may be slightly out of sync with the data gathered by `smaps`.
-* the **ptotal** (from 'smaps') and **pss** (from `smaps_rollups` and usually hidden) seem differ more than expected but still close.
-* after the first loop, **pss** is read and only groups with sufficient aggregate change are probed for the details.  Thus, subsequent loops are more efficient by avoiding the reading of `smaps` in many cases (with some loss of accuracy).
-* the "exe" value comes from the command line (based `/proc/{PID}/cmdline` which is a bit funky). Firstly, the leading path is stripped; secondly, if the resulting executable is a script interpreter (e.g., python, perl, bash, ...) AND the first argument seems to be a full path (i.e., starts with "/"), then the "exe" will be represented as "{interpreter}->{basename(script)}".  For example, "python3->pmemstat.py" in the example above.
-
-
-## Test Program and Test Suggestions
-The C program, `memtest.c` is included and can be compiled by running `cc memtest.c -o memtest`.  This program:
-* regularly allocates more memory of all types
-* can be run several times simultaneously,
-* will share SysV shared memory and memory mapped files,
-
-When running `pmemstat` to monitor its memory use and changes, you should use `-uKB` and `-k{small-number}` so that you can "see" the very modest memory use of the test program and its changes.
-
-Running a number of sleeps of various durations in the background in a loop, plus one foreground sleep, can make for a robustness tests with lots of processes coming and going.  There are many "races" (i.e., a process may appear in `/proc`, but its`smaps` is gone), and this test helps ensure the races are handled properly.
-
-## Alternative Installation Options
-If the `pipx` install is not acceptable, choose the best way to install:
-* **From PyPi as non-root**. You need `~/.local/bin` on your `$PATH`.
-```
-        python -m pip install --user pmemstat
-        # to uninstall: python -m pip uninstall pmemstat
-```
-* Or **from PyPi as root**. This makes `pmemstat` available to all users with `/usr/local/bin` on `$PATH`. Note: `PIP_BREAK_SYSTEM_PACKAGES=1` may be required on some distros.
-```
-        PIP_BREAK_SYSTEM_PACKAGES=1 sudo python -m pip install pmemstat
-        # to uninstall: sudo python -m pip uninstall pmemstat
-```

pmemstat-2.3.28/pyproject.toml

@@ -1,72 +0,0 @@
-# HOW TO PUBLISH...
-#
-# Prep Work (ensure need modules are up-to-date):
-#   sudo pacman -Syu python-pip
-#   sudo pacman -Syu python-build
-#   sudo pacman -Syu python-twine
-#   -- antiquated way
-#      python3 -m pip install --upgrade pip
-#      python3 -m pip install --upgrade build
-#      python3 -m pip install --upgrade twine
-# 
-# PUBLIC Build and deploy (from project directory):
-#   ## BUMP the version (below in [project])
-#   rm -r dist; python3 -m build; ls dist/.
-#   python3 -m twine upload dist/*
-#     ## Enter __token__ and the saved TOKEN (in bitwarden)
-#   pipx upgrade pmemstat || pipx install pmemstat # >= python3.11
-#   --OR-- sudo python3 -m pip install pmemstat # <= python3.10
-#   ## VISIT  https://pypi.org/project/pmemstat and delete old versions
-#
-# TEST Build and test (from project directory):
-#   ## BUMP the version (below in [project])
-#   rm -r dist; python3 -m build
-#   python3 -m twine upload --repository testpypi dist/*
-#     ## Enter __token__ and the saved TOKEN (in bitwarden)
-#   sudo python3 -m pip install --index-url https://test.pypi.org/simple/ --no-deps pmemstat
-#   ## VISIT  https://test.pypi.org/project/pmemstat and delete old versions
-
-[build-system]
-requires = ["setuptools>=42", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "pmemstat"
-version = "2.3.28"
-description = "Report Proportional Memory on Linux"
-authors = [
-    {name = "Joe Defen", email = "joedef@duck.com"},
-]
-readme = "README.md"
-license = { text = "MIT" }
-requires-python = ">=3.8"
-
-keywords = ["proportional memory", "RAM", "htop", "top", "monitor"]
-
-classifiers = [
-    "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: MIT License",
-    "Operating System :: POSIX :: Linux"
-]
-
-dependencies = [
-    'psutil>5.9',
-]
-
-[project.urls]
-"Homepage" = "https://github.com/joedefen/pmemstat"
-"Bug Tracker" = "https://github.com/joedefen/pmemstat/issues"
-
-[project.scripts]
-pmemstat = "pmemstat.main:run"
-
-[tool.setuptools]
-package-dir = {"" = "src"}
-
-[tool.setuptools.packages.find]
-where = ["src"]
-
-[tool.setuptools.package-data]
-exclude = [
-    "__pycache__",
-]

pmemstat-2.3.28/setup.cfg

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

pmemstat-2.3.28/src/pmemstat.egg-info/SOURCES.txt

@@ -1,14 +0,0 @@
-LICENSE.txt
-README.md
-pyproject.toml
-src/pmemstat/CpuSmooth.py
-src/pmemstat/KillThem.py
-src/pmemstat/Window.py
-src/pmemstat/__init__.py
-src/pmemstat/main.py
-src/pmemstat.egg-info/PKG-INFO
-src/pmemstat.egg-info/SOURCES.txt
-src/pmemstat.egg-info/dependency_links.txt
-src/pmemstat.egg-info/entry_points.txt
-src/pmemstat.egg-info/requires.txt
-src/pmemstat.egg-info/top_level.txt

pmemstat-2.3.28/src/pmemstat.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

pmemstat-2.3.28/src/pmemstat.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-pmemstat = pmemstat.main:run

pmemstat-2.3.28/src/pmemstat.egg-info/requires.txt

@@ -1 +0,0 @@
-psutil>5.9

pmemstat-2.3.28/src/pmemstat.egg-info/top_level.txt

@@ -1 +0,0 @@
-pmemstat