pycfutils 2024.5.8__py3-none-any.whl

pycfutils/__init__.py

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

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/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/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/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/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/tests/__init__.py

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

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/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/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/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.dist-info/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,16 @@
+pycfutils/__init__.py,sha256=KfnpE2DO2NB_2acg0Gc3ti6llSM8zuYUSXtmRXB9ZqI,76
+pycfutils/common.py,sha256=E2TLZsogyxwQlB4huE9GKQ0XR56prWOwISX9_Q0vymE,1615
+pycfutils/ctypes.py,sha256=Gh0XxHc1SC5rlQG5aIADwTsjMKOYe-TtL1_4_LenT6o,3033
+pycfutils/keyboard.py,sha256=eMAjeCb1hATL4IPdaXjCkjwuhOHp1uC_bZBXDXNupJI,2291
+pycfutils/gui/__init__.py,sha256=HXAIbSR5cCrzd-oz-1NVCbiowK2eXsKJm59dIO_8hgg,1376
+pycfutils/gui/constants.py,sha256=1IU9V7lC0x6L809DtbT73mTw5fSiWCPmCPoOf1opxP8,2052
+pycfutils/tests/__init__.py,sha256=KfnpE2DO2NB_2acg0Gc3ti6llSM8zuYUSXtmRXB9ZqI,76
+pycfutils/tests/test_common.py,sha256=o6llfAVTo1uus8i6WjjjYdasKo8ehFFblXTIjIboyAQ,2583
+pycfutils/tests/test_ctypes.py,sha256=DYdwf6YfpndysTCKcviYcqiejDDZcI07nGP5JiCzCbw,809
+pycfutils/tests/test_gui.py,sha256=G32_Rak3k7KDoHUKOHgeFET-Rcb4w9CWJjJlfJn7vSw,403
+pycfutils/tests/test_keyboard.py,sha256=ntD3PtdJnTBiYWiAdI8yBzu3421LPzsvXusWofhuy3s,382
+pycfutils-2024.5.8.dist-info/LICENSE,sha256=kf8dqfk_H2Xt3LmvUktDZmFubGK1xzfl_63jompMkQU,1073
+pycfutils-2024.5.8.dist-info/METADATA,sha256=RM80Aw_nygkwm9ec_1E5nP2DHIUpIfwugMUZZsfKmto,1500
+pycfutils-2024.5.8.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pycfutils-2024.5.8.dist-info/top_level.txt,sha256=KV3mT8aaA6pjo3iiPx1ROIfllPX8tb5Z3StPRKebGj0,10
+pycfutils-2024.5.8.dist-info/RECORD,,

pycfutils-2024.5.8.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.38.4)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pycfutils-2024.5.8.dist-info/top_level.txt

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