pycfutils 2024.5.8__tar.gz

pycfutils-2024.5.8/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-2024 Cristi Fati
+
+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.

pycfutils-2024.5.8/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.1
+Name: pycfutils
+Version: 2024.5.8
+Summary: PyCFUtils (Cristi Fati's Utils for Python (&& more)) - a collection of (cool) scripts / utilities
+Home-page: https://github.com/CristiFati/pycfutils
+Download-URL: https://pypi.org/project/pycfutils
+Author: Cristi Fati
+Author-email: fati_utcluj@yahoo.com
+Maintainer: Cristi Fati
+Maintainer-email: fati_utcluj@yahoo.com
+License: MIT
+Platform: All
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: C
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# *PyCFUtils*
+
+*PyCFUtils* (**C**risti **F**ati's ***Utils*** for ***Py**thon* (&& more)) - a collection of (cool) scripts / utilities
+
+
+## Install
+
+Use *PIP*:
+
+```shell
+python -m pip install --upgrade pycfutils
+```
+
+
+## Usage example
+
+```python
+import pycfutils.common
+import pycfutils.keyboard
+
+print("Press a key...")
+print(pycfutils.keyboard.read_key())
+print(pycfutils.common.timestamp_string(human_readable=True))
+
+# --- Windows only ---
+import pycfutils.gui
+
+pycfutils.gui.message_box("Title", "Text to display", 200, 200)
+```
+

pycfutils-2024.5.8/README.md

@@ -0,0 +1,30 @@
+# *PyCFUtils*
+
+*PyCFUtils* (**C**risti **F**ati's ***Utils*** for ***Py**thon* (&& more)) - a collection of (cool) scripts / utilities
+
+
+## Install
+
+Use *PIP*:
+
+```shell
+python -m pip install --upgrade pycfutils
+```
+
+
+## Usage example
+
+```python
+import pycfutils.common
+import pycfutils.keyboard
+
+print("Press a key...")
+print(pycfutils.keyboard.read_key())
+print(pycfutils.common.timestamp_string(human_readable=True))
+
+# --- Windows only ---
+import pycfutils.gui
+
+pycfutils.gui.message_box("Title", "Text to display", 200, 200)
+```
+

pycfutils-2024.5.8/pycfutils/__init__.py

@@ -0,0 +1 @@
+# @TODO - cfati: Dummy file - dir is picked up by setuptools.find_packages

pycfutils-2024.5.8/pycfutils/common.py

@@ -0,0 +1,64 @@
+import math
+import sys
+import time
+from datetime import datetime
+from typing import Sequence, Tuple, Union
+
+__all__ = (
+    "int_format",
+    "timestamp_string",
+    "dimensions_2d",
+    "uniques",
+)
+
+
+def int_format(limit: int) -> str:
+    sgn = 1 if limit < 0 else 0
+    return f"{{:0{math.ceil(math.log10(max(abs(limit), 2))) + sgn:d}d}}"
+
+
+def timestamp_string(
+    timestamp: Union[None, int, float, Sequence] = None,
+    human_readable: bool = False,
+    date_separator: str = "-",
+    time_separator: str = ":",
+    separator: str = " ",
+) -> str:
+    tm = (
+        time.gmtime(timestamp)
+        if timestamp is None or isinstance(timestamp, (int, float))
+        else timestamp.timetuple()
+        if isinstance(timestamp, datetime)
+        else timestamp
+    )[:6]
+    if human_readable:
+        return (
+            f"{tm[0]:04d}{date_separator}"
+            f"{tm[1]:02d}{date_separator}"
+            f"{tm[2]:02d}{separator}"
+            f"{tm[3]:02d}{time_separator}"
+            f"{tm[4]:02d}{time_separator}{tm[5]:02d}"
+        )
+    return f"{tm[0]:04d}{tm[1]:02d}{tm[2]:02d}{tm[3]:02d}{tm[4]:02d}{tm[5]:02d}"
+
+
+def dimensions_2d(n: int) -> Tuple:
+    if n <= 0:
+        return 0, 0
+    sq = round(math.sqrt(n))
+    return sq, math.ceil(n / sq)
+
+
+def uniques(sequence: Sequence) -> Sequence:
+    ret = []
+    handled = set()
+    for e in sequence:
+        if e not in handled:
+            ret.append(e)
+            handled.add(e)
+    return ret if isinstance(sequence, list) else tuple(ret)
+
+
+if __name__ == "__main__":
+    print("This script is not meant to be run directly.\n")
+    sys.exit(-1)

pycfutils-2024.5.8/pycfutils/ctypes.py

@@ -0,0 +1,119 @@
+import ctypes as cts
+import sys
+from typing import Any, Optional
+
+cts.c_bool = 1
+try:
+    _CLS_CDATA = cts.c_int.__mro__[-2]
+except Exception:
+    _CLS_CDATA = None
+
+
+__all__ = ("to_string",)
+
+
+def _to_string(
+    obj: Any,
+    indent: int,
+    prefix: Optional[str],
+    suffix: Optional[str],
+    indent_text: str,
+    indent_first_line: bool,
+) -> str:
+    cls = obj.__class__
+    ret = [prefix] if prefix is not None else []
+    ret.append(f"{(indent_text * indent) if indent_first_line else '':s}{obj}")
+    if _CLS_CDATA is None or not issubclass(cls, _CLS_CDATA):
+        if suffix is not None:
+            ret.append(suffix)
+        return "\n".join(ret)
+    if issubclass(cls, (cts.Structure, cts.Union)):
+        for name, _ in obj._fields_:
+            ret.append(
+                "{:s}{:s}: {:s}".format(
+                    indent_text * (indent + 1),
+                    name,
+                    _to_string(
+                        obj=getattr(obj, name),
+                        indent=indent + 1,
+                        prefix=None,
+                        suffix=None,
+                        indent_text=indent_text,
+                        indent_first_line=False,
+                    ),
+                )
+            )
+    elif issubclass(cls, cts.Array):
+        for e in obj:
+            ret.append(
+                _to_string(
+                    obj=e,
+                    indent=indent + 1,
+                    prefix=None,
+                    suffix=None,
+                    indent_text=indent_text,
+                    indent_first_line=True,
+                )
+            )
+    elif issubclass(cls, cts._Pointer):
+        if obj:
+            ret.append(
+                _to_string(
+                    obj=obj.contents,
+                    indent=indent + 1,
+                    prefix=prefix,
+                    suffix=suffix,
+                    indent_text=indent_text,
+                    indent_first_line=True,
+                )
+            )
+    if suffix is not None:
+        ret.append(suffix)
+    return "\n".join(ret)
+
+
+def to_string(
+    obj: Any,
+    indent: int = 0,
+    prefix: Optional[str] = "",
+    suffix: Optional[str] = "",
+    indent_text: str = "  ",
+) -> str:
+    return _to_string(
+        obj=obj,
+        indent=indent,
+        prefix=prefix,
+        suffix=suffix,
+        indent_text=indent_text,
+        indent_first_line=True,
+    )
+
+
+if _CLS_CDATA:
+    __all__ += (
+        "Structure",
+        "Union",
+        # "Array",
+        "BigEndianStructure",
+        "LittleEndianStructure",
+    )
+
+    class Structure(cts.Structure):
+        to_string = to_string
+
+    class Union(cts.Union):
+        to_string = to_string
+
+    #    class Array(cts.Array):
+    #        to_string = to_string
+
+    class BigEndianStructure(cts.BigEndianStructure):
+        to_string = to_string
+
+    class LittleEndianStructure(cts.LittleEndianStructure):
+        to_string = to_string
+
+
+if __name__ == "__main__":
+    print("This script is not meant to be run directly.\n")
+    sys.exit(-1)

pycfutils-2024.5.8/pycfutils/gui/__init__.py

@@ -0,0 +1,66 @@
+import atexit
+import ctypes as cts
+import os
+import sys
+from typing import Optional
+
+__all__ = ()
+
+_IS_WIN = sys.platform[:3].lower() == "win"
+_DLL_NAME = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+    f"libcinterface.{'dll' if _IS_WIN else 'so'}",
+)
+
+if _IS_WIN:
+    from ctypes import wintypes as wts
+
+    __all__ += ("message_box",)
+
+    _DLL = cts.CDLL(_DLL_NAME)
+
+    _MessageBoxXY = _DLL.MessageBoxXY
+    _MessageBoxXY.argtypes = (
+        wts.HWND,
+        wts.LPCWSTR,
+        wts.LPCWSTR,
+        wts.UINT,
+        cts.c_int,
+        cts.c_int,
+    )
+    _MessageBoxXY.restype = cts.c_int
+
+    def message_box(
+        title: str,
+        text: str,
+        x: Optional[int] = None,
+        y: Optional[int] = None,
+        style: int = 0,
+        hwnd: Optional[wts.HWND] = None,
+    ) -> int:
+        return _MessageBoxXY(
+            hwnd,
+            text,
+            title,
+            style,
+            x if x is not None else 0x80000000,
+            y if y is not None else 0x80000000,
+        )
+
+    _clearHooks = _DLL.clearHooks
+    _clearHooks.argtypes = ()
+    _clearHooks.restype = cts.c_int
+    atexit.register(_clearHooks)
+    del _clearHooks
+else:  # Nix
+    _DLL = None
+
+
+del _DLL
+del _DLL_NAME
+del _IS_WIN
+
+
+if __name__ == "__main__":
+    print("This script is not meant to be run directly.\n")
+    sys.exit(-1)

pycfutils-2024.5.8/pycfutils/gui/constants.py

@@ -0,0 +1,81 @@
+"""
+Module containing package constants.
+
+NOTE:
+Due to the fact that for MessageBox there had to be added ~50 of them,
+it's not scalable, so they (or the entire module)
+might be removed in the future.
+
+Please use some specialized packages (if any) that export them.
+For MessageBox, win32con can be used (https://github.com/mhammond/pywin32).
+
+"""
+import sys
+import warnings
+
+warnings.warn("This module might be removed in the future")
+
+__IS_WIN = sys.platform[:3].lower() == "win"
+
+if __IS_WIN:
+    MB_OK = 0x00000000
+    MB_OKCANCEL = 0x00000001
+    MB_ABORTRETRYIGNORE = 0x00000002
+    MB_YESNOCANCEL = 0x00000003
+    MB_YESNO = 0x00000004
+    MB_RETRYCANCEL = 0x00000005
+    MB_CANCELTRYCONTINUE = 0x00000006
+    MB_ICONHAND = 0x00000010
+    MB_ICONQUESTION = 0x00000020
+    MB_ICONEXCLAMATION = 0x00000030
+    MB_ICONASTERISK = 0x00000040
+    MB_USERICON = 0x00000080
+    MB_ICONWARNING = MB_ICONEXCLAMATION
+    MB_ICONERROR = MB_ICONHAND
+    MB_ICONINFORMATION = MB_ICONASTERISK
+    MB_ICONSTOP = MB_ICONHAND
+    MB_DEFBUTTON1 = 0x00000000
+    MB_DEFBUTTON2 = 0x00000100
+    MB_DEFBUTTON3 = 0x00000200
+    MB_DEFBUTTON4 = 0x00000300
+    MB_APPLMODAL = 0x00000000
+    MB_SYSTEMMODAL = 0x00001000
+    MB_TASKMODAL = 0x00002000
+    MB_HELP = 0x00004000
+    MB_NOFOCUS = 0x00008000
+    MB_SETFOREGROUND = 0x00010000
+    MB_DEFAULT_DESKTOP_ONLY = 0x00020000
+    MB_TOPMOST = 0x00040000
+    MB_RIGHT = 0x00080000
+    MB_RTLREADING = 0x00100000
+    MB_SERVICE_NOTIFICATION = 0x00200000
+    MB_SERVICE_NOTIFICATION = 0x00040000
+    MB_SERVICE_NOTIFICATION_NT3X = 0x00040000
+    MB_TYPEMASK = 0x0000000F
+    MB_ICONMASK = 0x000000F0
+    MB_DEFMASK = 0x00000F00
+    MB_MODEMASK = 0x00003000
+    MB_MISCMASK = 0x0000C000
+
+    IDOK = 1
+    IDCANCEL = 2
+    IDABORT = 3
+    IDRETRY = 4
+    IDIGNORE = 5
+    IDYES = 6
+    IDNO = 7
+    IDCLOSE = 8
+    IDHELP = 9
+    IDTRYAGAIN = 10
+    IDCONTINUE = 11
+    IDTIMEOUT = 32000
+
+# else:  # Nix
+
+
+del __IS_WIN
+
+
+if __name__ == "__main__":
+    print("This script is not meant to be run directly.\n")
+    sys.exit(-1)

pycfutils-2024.5.8/pycfutils/include/pycfutils/cinterface.h

@@ -0,0 +1,38 @@
+// LibCInterface prototypes
+#pragma once
+
+#if defined(_WIN32)
+#  if defined(LIBCINTERFACE_STATIC)
+#    define LIBCINTERFACE_EXPORT_API
+#  else  // LIBCINTERFACE_STATIC
+#    if defined(LIBCINTERFACE_EXPORTS)
+#      define LIBCINTERFACE_EXPORT_API __declspec(dllexport)
+#    else  // LIBCINTERFACE_EXPORTS
+#      define LIBCINTERFACE_EXPORT_API __declspec(dllimport)
+#    endif  // LIBCINTERFACE_EXPORTS
+#  endif  // LIBCINTERFACE_STATIC
+#else  // _WIN32
+#  define LIBCINTERFACE_EXPORT_API
+#endif  // _WIN32
+
+#if defined(_WIN32)
+#  include <Windows.h>
+#else  // _WIN32
+#endif  // _WIN32
+
+#if defined(__cplusplus)
+extern "C" {
+#endif  // __cplusplus
+
+#  if defined(_WIN32)
+
+LIBCINTERFACE_EXPORT_API int MessageBoxXY(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType, int x, int y);
+LIBCINTERFACE_EXPORT_API int clearHooks();
+
+#  else  // _WIN32
+#  endif  // _WIN32
+
+#if defined(__cplusplus)
+}
+#endif  // __cplusplus
+

pycfutils-2024.5.8/pycfutils/keyboard.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python
+
+import functools
+import sys
+import time
+from typing import Any, Callable, Optional
+
+__all__ = ("read_key",)
+
+
+def _read_key(
+    interval: float = 0.5,
+    poll_interval: float = 0.1,
+    kp_func: Optional[Callable[[], bool]] = None,
+    rk_func: Optional[Callable[[], int]] = None,
+    start_func: Optional[Callable[[], Any]] = None,
+    end_func: Optional[Callable[[Any], None]] = None,
+):
+    ctx = start_func() if start_func is not None else None
+    try:
+        poll_interval = (
+            interval / 2.0 if poll_interval > interval / 2.0 else poll_interval
+        )
+        time_end = time.time() + interval
+        while True:
+            if kp_func is not None and kp_func():
+                return rk_func() if rk_func is not None else None
+            if time.time() >= time_end:
+                break
+            time.sleep(poll_interval)
+        return None
+    finally:
+        if end_func is not None:
+            end_func(ctx)
+
+
+if sys.platform[:3].lower() == "win":
+    import msvcrt
+
+    def _key_pressed_func() -> bool:
+        return msvcrt.kbhit()
+
+    def _read_key_func() -> int:
+        return ord(msvcrt.getch())
+
+    _start_func = None
+    _end_func = None
+
+
+else:  # Nix
+    import select
+    import termios
+    import tty
+
+    def _key_pressed_func() -> bool:
+        return sys.stdin in select.select([sys.stdin], [], [], 0)[0]
+
+    def _read_key_func() -> int:
+        return ord(sys.stdin.read(1))
+
+    def _start_func() -> Any:
+        attrs = termios.tcgetattr(sys.stdin)
+        tty.setcbreak(sys.stdin.fileno(), when=termios.TCSAFLUSH)
+        return attrs
+
+    def _end_func(attrs) -> None:
+        if attrs is not None:
+            termios.tcsetattr(sys.stdin, termios.TCSADRAIN, attrs)
+
+
+read_key = functools.partial(
+    _read_key,
+    kp_func=_key_pressed_func,
+    rk_func=_read_key_func,
+    start_func=_start_func,
+    end_func=_end_func,
+)
+
+del _end_func
+del _start_func
+del _read_key_func
+del _key_pressed_func
+
+
+if __name__ == "__main__":
+    exit_char = 0x1B  # Esc
+    print(f"Looping till 0x{exit_char:02X} is pressed")
+    while 1:
+        k = read_key()
+        if k is not None:
+            print(f"Pressed: 0x{k:02X} ({k:c})")
+            if k == exit_char:
+                print("Exit\n")
+                break

pycfutils-2024.5.8/pycfutils/src/cinterface_win.cpp

@@ -0,0 +1,122 @@
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <Windows.h>
+
+#define LIBCINTERFACE_EXPORTS
+#include "../include/pycfutils/cinterface.h"
+
+#define SENTINEL 0x80000000
+
+
+typedef std::unordered_map<DWORD, HHOOK> HookData;
+typedef std::pair<int, int> XY;
+typedef std::unordered_map<DWORD, std::vector<XY>> XYData;
+
+CRITICAL_SECTION criticalSection;
+XYData xyData;
+HookData hookData;
+
+
+static LRESULT CALLBACK _hookFunc(int nCode, WPARAM wParam, LPARAM lParam)
+{
+    if (nCode < 0) {
+        return CallNextHookEx(NULL, nCode, wParam, lParam);
+    }
+    switch (nCode) {
+        case HCBT_CREATEWND: {
+            EnterCriticalSection(&criticalSection);
+            DWORD tid = GetCurrentThreadId();
+            if (hookData.find(tid) != hookData.cend()) {
+                auto xyIt = xyData[tid].cbegin();
+                if (xyIt != xyData[tid].cend()) {
+                    LPCBT_CREATEWNDW pcw = (LPCBT_CREATEWNDW)lParam;
+                    if (pcw) {
+                        LPCREATESTRUCTW pcs = pcw->lpcs;
+                        if (pcs) {
+                            if (xyIt->first != SENTINEL) {
+                                pcs->x = xyIt->first;
+                            }
+                            if (xyIt->second != SENTINEL) {
+                                pcs->y = xyIt->second;
+                            }
+                        }
+                    }
+                    xyData[tid].erase(xyIt);
+                }
+            }
+            LeaveCriticalSection(&criticalSection);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+    return CallNextHookEx(NULL, nCode, wParam, lParam);
+}
+
+int MessageBoxXY(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType, int x, int y)
+{
+    EnterCriticalSection(&criticalSection);
+    DWORD tid = GetCurrentThreadId();
+    if (hookData.find(tid) == hookData.cend()) {
+        HHOOK hook = SetWindowsHookExW(WH_CBT, _hookFunc, 0, tid);
+        if (hook) {
+            hookData[tid] = hook;
+        }  // @TODO - cfati: Silently fail?
+    }
+    xyData[tid].emplace_back(std::make_pair(x, y));
+    LeaveCriticalSection(&criticalSection);
+    return MessageBoxW(hWnd, lpText, lpCaption, uType);
+}
+
+
+int clearHooks()
+{
+    int ret = 0;
+    EnterCriticalSection(&criticalSection);
+    for (auto it = hookData.cbegin(); it != hookData.cend(); ++it) {
+        if (UnhookWindowsHookEx(it->second)) {
+            ++ret;
+        }  // @TODO - cfati: Silently fail?
+    }
+    LeaveCriticalSection(&criticalSection);
+    return ret;
+}
+
+
+BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+{
+    // Perform actions based on the reason for calling.
+    switch (fdwReason) {
+        case DLL_PROCESS_ATTACH: {
+            // Initialize once for each new process.
+            // Return FALSE to fail DLL load.
+            InitializeCriticalSection(&criticalSection);
+            break;
+        }
+        case DLL_THREAD_ATTACH: {
+            // Do thread-specific initialization.
+            break;
+        }
+        case DLL_THREAD_DETACH: {
+            // Do thread-specific cleanup.
+            break;
+        }
+        case DLL_PROCESS_DETACH: {
+
+            if (lpvReserved != NULL) {
+                break; // do not do cleanup if process termination scenario
+            }
+            DeleteCriticalSection(&criticalSection);
+            // Perform any necessary cleanup.
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+    return TRUE;  // Successful DLL_PROCESS_ATTACH.
+}
+

pycfutils-2024.5.8/pycfutils/tests/__init__.py

@@ -0,0 +1 @@
+# @TODO - cfati: Dummy file - dir is picked up by setuptools.find_packages

pycfutils-2024.5.8/pycfutils/tests/test_common.py

@@ -0,0 +1,57 @@
+import unittest
+from datetime import datetime
+
+from pycfutils import common
+
+
+class CommonTestCase(unittest.TestCase):
+    def test_int_format(self):
+        self.assertEqual(common.int_format(-101), "{:04d}")
+        self.assertEqual(common.int_format(-100), "{:03d}")
+        self.assertEqual(common.int_format(-11), "{:03d}")
+        self.assertEqual(common.int_format(-10), "{:02d}")
+        self.assertEqual(common.int_format(-1), "{:02d}")
+        self.assertEqual(common.int_format(0), "{:01d}")
+        self.assertEqual(common.int_format(1), "{:01d}")
+        self.assertEqual(common.int_format(10), "{:01d}")
+        self.assertEqual(common.int_format(11), "{:02d}")
+        self.assertEqual(common.int_format(100), "{:02d}")
+        self.assertEqual(common.int_format(101), "{:03d}")
+
+    def test_timestamp_string(self):
+        ts = (2024, 5, 6, 12, 34, 56)
+        self.assertEqual(
+            common.timestamp_string(timestamp=ts, human_readable=False),
+            "20240506123456",
+        )
+        self.assertEqual(
+            common.timestamp_string(timestamp=ts, human_readable=True),
+            "2024-05-06 12:34:56",
+        )
+        self.assertTrue(common.timestamp_string(datetime.now()))
+
+    def test_uniques(self):
+        l0 = [1, 2, 3, 1, 4, 3, 5, 1, 1, 2, 6, 0, 0]
+        l1 = [1, 2, 3, 4, 5, 6, 0]
+        self.assertEqual(common.uniques([]), [])
+        self.assertEqual(common.uniques(()), ())
+        self.assertEqual(common.uniques(range(3)), (0, 1, 2))
+        self.assertEqual(common.uniques(l0), l1)
+        self.assertEqual(common.uniques((e for e in l0)), tuple(l1))
+        self.assertEqual(set(common.uniques(set(l0))), set(l0))
+
+    def test_dimensions2d(self):
+        self.assertEqual(common.dimensions_2d(-3), (0, 0))
+        self.assertEqual(common.dimensions_2d(0), (0, 0))
+        self.assertEqual(common.dimensions_2d(1), (1, 1))
+        self.assertEqual(common.dimensions_2d(2), (1, 2))
+        self.assertEqual(common.dimensions_2d(3), (2, 2))
+        self.assertEqual(common.dimensions_2d(4), (2, 2))
+        self.assertEqual(common.dimensions_2d(5), (2, 3))
+        self.assertEqual(common.dimensions_2d(6), (2, 3))
+        self.assertEqual(common.dimensions_2d(7), (3, 3))
+        self.assertEqual(common.dimensions_2d(8), (3, 3))
+        self.assertEqual(common.dimensions_2d(9), (3, 3))
+        self.assertEqual(common.dimensions_2d(10), (3, 4))
+        self.assertEqual(common.dimensions_2d(13), (4, 4))
+        self.assertEqual(common.dimensions_2d(20), (4, 5))

pycfutils-2024.5.8/pycfutils/tests/test_ctypes.py

@@ -0,0 +1,34 @@
+import ctypes as cts
+import unittest
+
+from pycfutils import ctypes
+
+FloatArr10 = cts.c_float * 10
+
+
+class S0(ctypes.Structure):
+    _fields_ = (
+        ("i", cts.c_int),
+        ("s", cts.c_char_p),
+        ("fa", FloatArr10),
+        ("pi", cts.POINTER(cts.c_int)),
+    )
+
+
+# @TODO - cfati: Dummy-ish
+class CTypesTestCase(unittest.TestCase):
+    def test_to_string(self):
+        self.assertEqual(ctypes.to_string(1), "\n1\n")
+
+    def test_structure(self):
+        i = cts.c_int(1234)
+        s0 = S0(
+            -32,
+            b"dummy text",
+            FloatArr10(*(float(e) for e in range(20, 30))),
+            cts.pointer(i),
+        )
+        s = s0.to_string(suffix=None)
+        # print(s)
+        self.assertIn("-32", s)
+        self.assertIn("dummy text", s)

pycfutils-2024.5.8/pycfutils/tests/test_gui.py

@@ -0,0 +1,14 @@
+import sys
+import unittest
+
+from pycfutils import gui
+
+
+# @TODO - cfati: Dummy
+class GUITestCase(unittest.TestCase):
+    def test_message_box(self):
+        message_box_name = "message_box"
+        if sys.platform[:3].lower() == "win":
+            self.assertIsNotNone(getattr(gui, message_box_name, None))
+        else:
+            self.assertIsNone(getattr(gui, message_box_name, None))

pycfutils-2024.5.8/pycfutils/tests/test_keyboard.py

@@ -0,0 +1,14 @@
+import time
+import unittest
+
+from pycfutils import keyboard
+
+
+class KwyboardTestCase(unittest.TestCase):
+    def test_read_key(self):
+        itv = 0.5
+        pitv = 0.1
+        margin = 0.05
+        ts = time.time()
+        k = keyboard.read_key(interval=itv, poll_interval=pitv)
+        self.assertTrue(k is not None or abs(time.time() - ts - itv) < pitv + margin)

pycfutils-2024.5.8/pycfutils.egg-info/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.1
+Name: pycfutils
+Version: 2024.5.8
+Summary: PyCFUtils (Cristi Fati's Utils for Python (&& more)) - a collection of (cool) scripts / utilities
+Home-page: https://github.com/CristiFati/pycfutils
+Download-URL: https://pypi.org/project/pycfutils
+Author: Cristi Fati
+Author-email: fati_utcluj@yahoo.com
+Maintainer: Cristi Fati
+Maintainer-email: fati_utcluj@yahoo.com
+License: MIT
+Platform: All
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: C
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# *PyCFUtils*
+
+*PyCFUtils* (**C**risti **F**ati's ***Utils*** for ***Py**thon* (&& more)) - a collection of (cool) scripts / utilities
+
+
+## Install
+
+Use *PIP*:
+
+```shell
+python -m pip install --upgrade pycfutils
+```
+
+
+## Usage example
+
+```python
+import pycfutils.common
+import pycfutils.keyboard
+
+print("Press a key...")
+print(pycfutils.keyboard.read_key())
+print(pycfutils.common.timestamp_string(human_readable=True))
+
+# --- Windows only ---
+import pycfutils.gui
+
+pycfutils.gui.message_box("Title", "Text to display", 200, 200)
+```
+

pycfutils-2024.5.8/pycfutils.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+setup.py
+pycfutils/__init__.py
+pycfutils/common.py
+pycfutils/ctypes.py
+pycfutils/keyboard.py
+pycfutils.egg-info/PKG-INFO
+pycfutils.egg-info/SOURCES.txt
+pycfutils.egg-info/dependency_links.txt
+pycfutils.egg-info/top_level.txt
+pycfutils/gui/__init__.py
+pycfutils/gui/constants.py
+pycfutils/tests/__init__.py
+pycfutils/tests/test_common.py
+pycfutils/tests/test_ctypes.py
+pycfutils/tests/test_gui.py
+pycfutils/tests/test_keyboard.py
+vs/vs.vcxproj
+vs/vs.vcxproj.filters
+vs/vs.sln
+pycfutils/include/pycfutils/cinterface.h
+pycfutils/src/cinterface_win.cpp

pycfutils-2024.5.8/pycfutils.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pycfutils-2024.5.8/pycfutils.egg-info/top_level.txt

@@ -0,0 +1 @@
+pycfutils

pycfutils-2024.5.8/setup.cfg

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

pycfutils-2024.5.8/setup.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python
+
+"""
+Still using setup.py, as I didn't get up to speed with pyproject.toml,
+especially due to the workarounds (some quite lame) done to build the .dll.
+"""
+
+import glob
+import os
+import sys
+
+from setuptools import find_packages, setup
+from setuptools.command.build_ext import build_ext
+from setuptools.command.sdist import sdist
+from setuptools.extension import Library
+from wheel.bdist_wheel import bdist_wheel
+
+_IS_WIN = sys.platform[:3].lower() == "win"
+
+_NAME = "pycfutils"
+_VERSION = "2024.05.08"
+
+if _IS_WIN:
+    _EXT = ".dll"
+    _SUF = "win"
+else:
+    _EXT = ".so"
+    _SUF = "nix"
+
+_INCLUDE_DIR = f"include/{_NAME}"
+_INCLUDE_FILES = (f"{_INCLUDE_DIR}/cinterface.h",)
+_SOURCE_FILES = [
+    e.replace("\\", "/")
+    for e in glob.glob(os.path.join(_NAME, "src", f"cinterface_*.cpp"))
+]
+_VS_FILES = tuple(
+    f"vs/{e}"
+    for e in (
+        "vs.vcxproj",
+        "vs.vcxproj.filters",
+        "vs.sln",
+    )
+)
+
+
+# @TODO - cfati (gainarie): Get rid of sysconfig's EXT_SUFFIX (e.g.: .cp310-win_amd64)
+class BuildDll(build_ext):
+    def get_ext_filename(self, ext_name):
+        return os.path.join(*ext_name.split(".")) + _EXT
+
+
+# @TODO - cfati (gainarie): Create generic .whl as the .dll doesn't depend on Python
+class BDistWheelDll(bdist_wheel):
+    def get_tag(self):
+        if _IS_WIN:
+            plat = self.plat_name.replace("-", "_").replace(".", "_").replace(" ", "_")
+        else:
+            plat = "any"
+        return (
+            "py3",
+            "none",
+            plat,
+        )
+
+
+# @TODO - cfati (gainarie): Manually add files in the source distribution (built on Nix)
+class SDist(sdist):
+    @staticmethod
+    def _extra_files():
+        ret = list(_VS_FILES)
+        if _IS_WIN:
+            return ret
+        ret.extend((os.path.join(_NAME, e) for e in _INCLUDE_FILES))
+        ret.extend(_SOURCE_FILES)
+        return ret
+
+    def _adjust_sources(self):
+        ei_cmd = super().get_finalized_command("egg_info")
+        manifest = os.path.join(ei_cmd.egg_info, "SOURCES.txt")
+        existing = [e.rstrip() for e in open(manifest).readlines()]
+        modified = False
+        for file in self._extra_files():
+            if file not in existing:
+                modified = True
+                existing.append(file)
+        if modified:
+            with open(manifest, mode="w") as f:
+                f.writelines((f"{e}\n" for e in existing))
+
+    def get_finalized_command(self, command, create=1):
+        cmd = super().get_finalized_command(command, create=create)
+        extra = self._extra_files()
+        if extra:
+            cmd.filelist.files.extend(extra)
+            self._adjust_sources()
+        return cmd
+
+
+c_interface_dll = Library(
+    (_NAME + ".libcinterface"),
+    sources=_SOURCE_FILES,
+    include_dirs=[f"{_NAME}/include"],
+    define_macros=[
+        ("UNICODE", None),
+        ("_UNICODE", None),
+        ("WIN32", None),
+        ("_WINDLL", None),
+    ],
+    extra_link_args=[
+        "/DLL",
+    ],
+    libraries=[
+        "user32",
+        "kernel32",
+    ],
+)
+
+setup_args = dict(
+    name=_NAME,
+    version=_VERSION,
+    description="PyCFUtils (Cristi Fati's Utils for Python (&& more)) - "
+    "a collection of (cool) scripts / utilities",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    author="Cristi Fati",
+    author_email="fati_utcluj@yahoo.com",
+    maintainer="Cristi Fati",
+    maintainer_email="fati_utcluj@yahoo.com",
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: MacOS",
+        "Operating System :: Microsoft :: Windows",
+        "Operating System :: POSIX",
+        "Operating System :: Unix",
+        "Programming Language :: C",
+        "Programming Language :: C++",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3 :: Only",
+        "Topic :: Software Development",
+    ],
+    platforms=("All",),
+    license="MIT",
+    url=f"https://github.com/CristiFati/{_NAME}",
+    download_url=f"https://pypi.org/project/{_NAME}",
+    packages=find_packages(
+        include=(f"{_NAME}", f"{_NAME}.gui", f"{_NAME}.tests"),
+        exclude=("src", "__pycache__"),
+    ),
+    package_data={
+        f"{_NAME}": _INCLUDE_FILES if _IS_WIN else (),
+    },
+    cmdclass={
+        "build_ext": BuildDll,
+        "bdist_wheel": BDistWheelDll,
+        "sdist": SDist,
+    },
+    ext_modules=[c_interface_dll] if _IS_WIN else [],
+)
+
+setup(**setup_args)

pycfutils-2024.5.8/vs/vs.sln

@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.34729.46
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vs", "vs.vcxproj", "{E67CC532-0677-49C4-95AD-0FEFDCA7865D}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{E67CC532-0677-49C4-95AD-0FEFDCA7865D}.Debug|x64.ActiveCfg = Debug|x64
+		{E67CC532-0677-49C4-95AD-0FEFDCA7865D}.Debug|x64.Build.0 = Debug|x64
+		{E67CC532-0677-49C4-95AD-0FEFDCA7865D}.Debug|x86.ActiveCfg = Debug|Win32
+		{E67CC532-0677-49C4-95AD-0FEFDCA7865D}.Debug|x86.Build.0 = Debug|Win32
+		{E67CC532-0677-49C4-95AD-0FEFDCA7865D}.Release|x64.ActiveCfg = Release|x64
+		{E67CC532-0677-49C4-95AD-0FEFDCA7865D}.Release|x64.Build.0 = Release|x64
+		{E67CC532-0677-49C4-95AD-0FEFDCA7865D}.Release|x86.ActiveCfg = Release|Win32
+		{E67CC532-0677-49C4-95AD-0FEFDCA7865D}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {54F052B3-B473-45EE-B8F2-F621E5EEB6C3}
+	EndGlobalSection
+EndGlobal

pycfutils-2024.5.8/vs/vs.vcxproj

@@ -0,0 +1,167 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>16.0</VCProjectVersion>
+    <Keyword>Win32Proj</Keyword>
+    <ProjectGuid>{e67cc532-0677-49c4-95ad-0fefdca7865d}</ProjectGuid>
+    <RootNamespace>cinterface</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <OutDir>$(SolutionDir)$(Platform)-$(Configuration)\</OutDir>
+    <IntDir>$(Platform)-$(Configuration)\</IntDir>
+    <TargetName>libcinterface</TargetName>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <OutDir>$(SolutionDir)$(Platform)-$(Configuration)\</OutDir>
+    <IntDir>$(Platform)-$(Configuration)\</IntDir>
+    <TargetName>libcinterface</TargetName>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <OutDir>$(SolutionDir)$(Platform)-$(Configuration)\</OutDir>
+    <IntDir>$(Platform)-$(Configuration)\</IntDir>
+    <TargetName>libcinterface</TargetName>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <OutDir>$(SolutionDir)$(Platform)-$(Configuration)\</OutDir>
+    <IntDir>$(Platform)-$(Configuration)\</IntDir>
+    <TargetName>libcinterface</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\pycfutils\src\cinterface_win.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</ExcludedFromBuild>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\pycfutils\include\pycfutils\cinterface.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

pycfutils-2024.5.8/vs/vs.vcxproj.filters

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\pycfutils\src\cinterface_win.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\pycfutils\include\pycfutils\cinterface.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>