omdev 0.0.0.dev114__tar.gz → 0.0.0.dev116__tar.gz

{omdev-0.0.0.dev114/omdev.egg-info → omdev-0.0.0.dev116}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omdev
-Version: 0.0.0.dev114
+Version: 0.0.0.dev116
 Summary: omdev
 Author: wrmsr
 License: BSD-3-Clause
@@ -12,7 +12,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Operating System :: POSIX
 Requires-Python: >=3.12
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev114
+Requires-Dist: omlish==0.0.0.dev116
 Provides-Extra: all
 Requires-Dist: black~=24.10; extra == "all"
 Requires-Dist: pycparser~=2.22; extra == "all"

{omdev-0.0.0.dev114 → omdev-0.0.0.dev116}/omdev/.manifests.json

@@ -51,7 +51,7 @@
     "module": ".cli.clicli",
     "attr": "_CLI_MODULE",
     "file": "omdev/cli/clicli.py",
-    "line": 111,
+    "line": 113,
     "value": {
       "$.cli.types.CliModule": {
         "cmd_name": "cli",
@@ -243,7 +243,7 @@
     "module": ".tools.git",
     "attr": "_CLI_MODULE",
     "file": "omdev/tools/git.py",
-    "line": 182,
+    "line": 196,
     "value": {
       "$.cli.types.CliModule": {
         "cmd_name": "git",

{omdev-0.0.0.dev114 → omdev-0.0.0.dev116}/omdev/cli/clicli.py

@@ -89,6 +89,8 @@ class CliCli(ap.Cli):
         print('Continue with reinstall? (ctrl-c to cancel)')
         input()
 
+        #
+
         if self.args.local:
             install_src = inspect.getsource(install)
         else:

{omdev-0.0.0.dev114 → omdev-0.0.0.dev116}/omdev/cli/main.py

@@ -1,6 +1,5 @@
 """
 TODO:
- - py/foo - root command 'py'
  - cache ldr.discover() somehow if in uvx/pipx - very slow
   - <venv-root>/.omdev-cli-manifest-cache.json - {pkg_name: manifests_json}
  - allow manually specifying manifest packages

omdev-0.0.0.dev116/omdev/clipboard/clipboard.py

@@ -0,0 +1,74 @@
+""" https://askubuntu.com/questions/11925/a-command-line-clipboard-copy-and-paste-utility
+"""
+import abc
+import dataclasses as dc
+import subprocess
+import typing as ta
+
+from omlish import lang
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ClipboardContents(lang.Abstract):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class TextClipboardContents(ClipboardContents):
+    s: str
+
+
+@dc.dataclass(frozen=True)
+class ImageClipboardContents(ClipboardContents):
+    b: bytes
+
+
+##
+
+
+class Clipboard(abc.ABC):
+    @abc.abstractmethod
+    def get(self) -> list[ClipboardContents]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def put(self, c: ClipboardContents) -> None:
+        raise NotImplementedError
+
+
+##
+
+
+class TextCommandClipboard(Clipboard, lang.Abstract):
+    @property
+    @abc.abstractmethod
+    def _get_cmd(self) -> ta.Sequence[str]:
+        raise NotImplementedError
+
+    def get(self) -> list[ClipboardContents]:
+        s = subprocess.check_output(self._get_cmd).decode()
+        return [TextClipboardContents(s)]
+
+    @property
+    @abc.abstractmethod
+    def _put_cmd(self) -> ta.Sequence[str]:
+        raise NotImplementedError
+
+    def put(self, c: ClipboardContents) -> None:
+        if isinstance(c, TextClipboardContents):
+            subprocess.run(self._put_cmd, input=c.s.encode(), check=True)
+        else:
+            raise TypeError(c)
+
+
+class XclipLinuxClipboard(TextCommandClipboard):
+    _get_cmd = ('xclip', '-selection', 'clipboard', '-o')
+    _put_cmd = ('xclip', '-selection', 'clipboard')
+
+
+class PbcopyDarwinClipboard(TextCommandClipboard):
+    _get_cmd = ('pbpaste',)
+    _put_cmd = ('pbcopy',)

omdev-0.0.0.dev114/omdev/clipboard/darwin.py → omdev-0.0.0.dev116/omdev/clipboard/darwin_cf.py

@@ -1,31 +1,4 @@
 # ruff: noqa: N802 N816
-"""
-        imageProperties = dict(
-            ColorModel = "RGB"
-            DPIHeight = 144
-            DPIWidth = 144
-            Depth = 8
-            PixelHeight = 1236
-            PixelWidth = 602
-            ProfileName = "Color LCD"
-            kCGImageDestinationAllowAlpha = true
-            {Exif} = dict(
-                PixelXDimension = 602
-                PixelYDimension = 1236
-                UserComment = "Screenshot"
-            )
-            {PNG} = dict(
-                InterlaceType = 0
-                XPixelsPerMeter = 5669
-                YPixelsPerMeter = 5669
-            )
-            {TIFF} = dict(
-                ResolutionUnit = 2
-                XResolution = 144
-                YResolution = 144
-            )
-        )
-"""
 import ctypes as ct
 import ctypes.util
 import dataclasses as dc
@@ -34,6 +7,11 @@ import typing as ta
 
 from omlish import check
 
+from .clipboard import Clipboard
+from .clipboard import ClipboardContents
+from .clipboard import ImageClipboardContents
+from .clipboard import TextClipboardContents
+
 
 ##
 
@@ -254,6 +232,32 @@ def get_darwin_clipboard_data(
 ##
 
 
+_TEXT_TYPE = 'public.utf8-plain-text'
+_IMAGE_TYPE = 'public.png'
+
+
+class CfDarwinClipboard(Clipboard):
+
+    def get(self) -> list[ClipboardContents]:
+        ret: list[ClipboardContents] = []
+        for i in get_darwin_clipboard_data(types={_TEXT_TYPE, _IMAGE_TYPE}):
+            if i.type == _TEXT_TYPE:
+                if i.data is not None:
+                    ret.append(TextClipboardContents(i.data.decode('utf-8')))
+            elif i.type == _IMAGE_TYPE:
+                if i.data is not None:
+                    ret.append(ImageClipboardContents(i.data))
+            else:
+                raise KeyError(i.type)
+        return ret
+
+    def put(self, c: ClipboardContents) -> None:
+        raise TypeError(self)
+
+
+##
+
+
 def _main() -> None:
     for i in get_darwin_clipboard_data(skip_types={'public.heics'}):
         print(f'type: {i.type}, len: {len(i.data) if i.data is not None else None}')

omdev-0.0.0.dev116/omdev/clipboard/linux_x.py

@@ -0,0 +1,301 @@
+# ruff: noqa: RUF012
+# flake8: noqa: E302 E305
+import ctypes as ct
+import ctypes.util
+import sys
+
+
+##
+
+
+if getattr(sys, 'platform') != 'linux':
+    raise OSError(sys.platform)
+
+
+##
+# x11
+
+x11 = ct.CDLL(ct.util.find_library('X11'))
+
+#
+
+Atom = ct.c_ulong
+Bool = ct.c_int
+Display = ct.c_void_p
+Status = ct.c_int
+Time = ct.c_ulong
+Window = ct.c_ulong
+
+#
+
+class XEvent(ct.Structure):
+    _fields_ = [
+        ('type', ct.c_int),
+        ('xselection', ct.c_ulong * 24),  # noqa
+    ]
+
+#
+
+x11.XCloseDisplay.argtypes = [Display]
+x11.XCloseDisplay.restype = None
+
+x11.XConvertSelection.argtypes = [Display, Atom, Atom, Atom, Window, Time]
+x11.XConvertSelection.restype = None
+
+x11.XCreateSimpleWindow.argtypes = [
+    Display,
+    Window,
+    ct.c_int,
+    ct.c_int,
+    ct.c_uint,
+    ct.c_uint,
+    ct.c_uint,
+    ct.c_ulong,
+    ct.c_ulong,
+]
+x11.XCreateSimpleWindow.restype = Window
+
+x11.XDefaultScreen.argtypes = [Display]
+x11.XDefaultScreen.restype = ct.c_int
+
+x11.XDestroyWindow.argtypes = [Display, Window]
+x11.XDestroyWindow.restype = None
+
+x11.XFlush.argtypes = [Display]
+x11.XFlush.restype = None
+
+x11.XFree.argtypes = [ct.c_void_p]
+x11.XFree.restype = None
+
+x11.XGetWindowProperty.argtypes = [
+    Display,
+    Window,
+    Atom,
+    ct.c_long,
+    ct.c_long,
+    Bool,
+    Atom,
+    ct.POINTER(Atom),
+    ct.POINTER(ct.c_int),
+    ct.POINTER(ct.c_ulong),
+    ct.POINTER(ct.c_ulong),
+    ct.POINTER(ct.c_void_p),
+]
+x11.XGetWindowProperty.restype = Status
+
+x11.XInternAtom.argtypes = [Display, ct.c_char_p, Bool]
+x11.XInternAtom.restype = Atom
+
+x11.XNextEvent.argtypes = [Display, ct.POINTER(XEvent)]
+x11.XNextEvent.restype = None
+
+x11.XOpenDisplay.argtypes = [ct.c_char_p]
+x11.XOpenDisplay.restype = Display
+
+x11.XRootWindow.argtypes = [Display, ct.c_int]
+x11.XRootWindow.restype = Window
+
+
+##
+
+
+def atom_to_string(display, atom) -> str:
+    x11.XGetAtomName.argtypes = [Display, Atom]
+    x11.XGetAtomName.restype = ct.c_char_p
+    return x11.XGetAtomName(display, atom).decode('utf-8')
+
+
+##
+
+
+def get_clipboard_text(display, window):
+    clipboard = x11.XInternAtom(display, b'CLIPBOARD', False)
+    utf8_string = x11.XInternAtom(display, b'UTF8_STRING', False)
+    target_property = x11.XInternAtom(display, b'XSEL_DATA', False)
+
+    x11.XConvertSelection(
+        display,
+        clipboard,
+        utf8_string,
+        target_property,
+        window,
+        0,
+    )
+    x11.XFlush(display)
+
+    event = XEvent()
+    x11.XNextEvent(display, ct.byref(event))
+
+    if event.type != 31:  # SelectionNotify event type
+        print('Failed to receive SelectionNotify event')
+        return
+
+    if event.xselection[4] == 0:  # None
+        print('No clipboard data available')
+        return
+
+    actual_type = Atom()
+    actual_format = ct.c_int()
+    nitems = ct.c_ulong()
+    bytes_after = ct.c_ulong()
+    data = ct.c_void_p()
+
+    status = x11.XGetWindowProperty(
+        display,
+        window,
+        target_property,
+        0,
+        ~0,
+        False,
+        0,
+        ct.byref(actual_type),
+        ct.byref(actual_format),
+        ct.byref(nitems),
+        ct.byref(bytes_after),
+        ct.byref(data),
+    )
+    try:
+        if status != 0 or not data:
+            print('Failed to get clipboard data')
+            return
+
+        clipboard_text = ct.cast(data, ct.c_char_p).value
+        print(f'Clipboard text: {clipboard_text.decode("utf-8") if clipboard_text else ""}')
+
+    finally:
+        x11.XFree(data)
+
+
+def get_clipboard_image(display, window):
+    clipboard = x11.XInternAtom(display, b'CLIPBOARD', False)
+    target_property = x11.XInternAtom(display, b'XSEL_DATA', False)
+    targets_atom = x11.XInternAtom(display, b'TARGETS', False)
+
+    x11.XConvertSelection(
+        display,
+        clipboard,
+        targets_atom,
+        target_property,
+        window,
+        0,
+    )
+    x11.XFlush(display)
+
+    event = XEvent()
+    x11.XNextEvent(display, ct.byref(event))
+
+    if event.type != 31 or event.xselection[4] == 0:
+        print('Failed to receive SelectionNotify event for image')
+        return
+
+    actual_type = Atom()
+    actual_format = ct.c_int()
+    nitems = ct.c_ulong()
+    bytes_after = ct.c_ulong()
+    data = ct.c_void_p()
+
+    status = x11.XGetWindowProperty(
+        display,
+        window,
+        target_property,
+        0,
+        ~0,
+        False,
+        4,
+        ct.byref(actual_type),
+        ct.byref(actual_format),
+        ct.byref(nitems),
+        ct.byref(bytes_after),
+        ct.byref(data),
+    )
+    try:
+        if status != 0 or not data:
+            print('Failed to get available targets')
+            return
+
+        png_atom = x11.XInternAtom(display, b'image/png', False)
+        atoms = ct.cast(data, ct.POINTER(Atom))
+        for i in range(nitems.value):
+            if atoms[i] != png_atom:
+                continue
+
+            x11.XConvertSelection(
+                display,
+                clipboard,
+                png_atom,
+                target_property,
+                window,
+                0,
+            )
+            x11.XFlush(display)
+            x11.XNextEvent(display, ct.byref(event))
+
+            if event.type != 31 or event.xselection[4] == 0:
+                print('Failed to receive SelectionNotify event for PNG image')
+                return
+
+            status = x11.XGetWindowProperty(
+                display,
+                window,
+                target_property,
+                0,
+                ~0,
+                False,
+                0,
+                ct.byref(actual_type),
+                ct.byref(actual_format),
+                ct.byref(nitems),
+                ct.byref(bytes_after),
+                ct.byref(data),
+            )
+
+            if status == 0 and data:
+                data_bytes = ct.string_at(data.value, nitems.value)  # type: ignore
+
+                print(f'Clipboard image: {len(data_bytes)} bytes')
+
+            return
+
+        print('No image data available on clipboard')
+
+    finally:
+        if data:
+            x11.XFree(data)
+
+
+##
+
+
+def main() -> None:
+    display = x11.XOpenDisplay(None)
+    try:
+        if not display:
+            print('Failed to open X display')
+            return
+
+        screen = x11.XDefaultScreen(display)
+        window = x11.XCreateSimpleWindow(
+            display,
+            x11.XRootWindow(display, screen),
+            0,
+            0,
+            1,
+            1,
+            0,
+            0,
+            0,
+        )
+        try:
+            get_clipboard_text(display, window)
+            get_clipboard_image(display, window)
+
+        finally:
+            x11.XDestroyWindow(display, window)
+
+    finally:
+        if display:
+            x11.XCloseDisplay(display)
+
+
+if __name__ == '__main__':
+    main()

{omdev-0.0.0.dev114 → omdev-0.0.0.dev116}/omdev/git.py

@@ -228,7 +228,7 @@ untracked file, this is reported as ? as well.
 """  # noqa
 
 
-class GitStatusLineState(enum.Enum):
+class GitStatusState(enum.Enum):
     UNMODIFIED = ' '
     MODIFIED = 'M'
     FILE_TYPE_CHANGED = 'T'
@@ -242,16 +242,16 @@ class GitStatusLineState(enum.Enum):
     SUBMODULE_MODIFIED_CONTENT = 'm'
 
 
-_EXTRA_UNMERGED_GIT_STATUS_LINE_STATES: ta.FrozenSet[ta.Tuple[GitStatusLineState, GitStatusLineState]] = frozenset([
-    (GitStatusLineState.ADDED, GitStatusLineState.ADDED),
-    (GitStatusLineState.DELETED, GitStatusLineState.DELETED),
+_EXTRA_UNMERGED_GIT_STATUS_STATES: ta.FrozenSet[ta.Tuple[GitStatusState, GitStatusState]] = frozenset([
+    (GitStatusState.ADDED, GitStatusState.ADDED),
+    (GitStatusState.DELETED, GitStatusState.DELETED),
 ])
 
 
 @dc.dataclass(frozen=True)
-class GitStatusLine:
-    x: GitStatusLineState
-    y: GitStatusLineState
+class GitStatusItem:
+    x: GitStatusState
+    y: GitStatusState
 
     a: str
     b: ta.Optional[str]
@@ -259,9 +259,9 @@ class GitStatusLine:
     @property
     def is_unmerged(self) -> bool:
         return (
-            self.x is GitStatusLineState.UPDATED_BUT_UNMERGED or
-            self.y is GitStatusLineState.UPDATED_BUT_UNMERGED or
-            (self.x, self.y) in _EXTRA_UNMERGED_GIT_STATUS_LINE_STATES
+            self.x is GitStatusState.UPDATED_BUT_UNMERGED or
+            self.y is GitStatusState.UPDATED_BUT_UNMERGED or
+            (self.x, self.y) in _EXTRA_UNMERGED_GIT_STATUS_STATES
         )
 
     def __repr__(self) -> str:
@@ -275,7 +275,7 @@ class GitStatusLine:
         )
 
 
-def parse_git_status_line(l: str) -> GitStatusLine:
+def parse_git_status_line(l: str) -> GitStatusItem:
     if len(l) < 3 or l[2] != ' ':
         raise ValueError(l)
     x, y = l[0], l[1]
@@ -289,25 +289,25 @@ def parse_git_status_line(l: str) -> GitStatusLine:
     else:
         raise ValueError(l)
 
-    return GitStatusLine(
-        GitStatusLineState(x),
-        GitStatusLineState(y),
+    return GitStatusItem(
+        GitStatusState(x),
+        GitStatusState(y),
         a,
         b,
     )
 
 
-class GitStatus(ta.Sequence[GitStatusLine]):
-    def __init__(self, lines: ta.Iterable[GitStatusLine]) -> None:
+class GitStatus(ta.Sequence[GitStatusItem]):
+    def __init__(self, lines: ta.Iterable[GitStatusItem]) -> None:
         super().__init__()
 
         self._lst = list(lines)
 
-        by_x: ta.Dict[GitStatusLineState, list[GitStatusLine]] = {}
-        by_y: ta.Dict[GitStatusLineState, list[GitStatusLine]] = {}
+        by_x: ta.Dict[GitStatusState, list[GitStatusItem]] = {}
+        by_y: ta.Dict[GitStatusState, list[GitStatusItem]] = {}
 
-        by_a: ta.Dict[str, GitStatusLine] = {}
-        by_b: ta.Dict[str, GitStatusLine] = {}
+        by_a: ta.Dict[str, GitStatusItem] = {}
+        by_b: ta.Dict[str, GitStatusItem] = {}
 
         for l in self._lst:
             by_x.setdefault(l.x, []).append(l)
@@ -332,7 +332,7 @@ class GitStatus(ta.Sequence[GitStatusLine]):
 
     #
 
-    def __iter__(self) -> ta.Iterator[GitStatusLine]:
+    def __iter__(self) -> ta.Iterator[GitStatusItem]:
         return iter(self._lst)
 
     def __getitem__(self, index):
@@ -344,19 +344,19 @@ class GitStatus(ta.Sequence[GitStatusLine]):
     #
 
     @property
-    def by_x(self) -> ta.Mapping[GitStatusLineState, ta.Sequence[GitStatusLine]]:
+    def by_x(self) -> ta.Mapping[GitStatusState, ta.Sequence[GitStatusItem]]:
         return self._by_x
 
     @property
-    def by_y(self) -> ta.Mapping[GitStatusLineState, ta.Sequence[GitStatusLine]]:
+    def by_y(self) -> ta.Mapping[GitStatusState, ta.Sequence[GitStatusItem]]:
         return self._by_y
 
     @property
-    def by_a(self) -> ta.Mapping[str, GitStatusLine]:
+    def by_a(self) -> ta.Mapping[str, GitStatusItem]:
         return self._by_a
 
     @property
-    def by_b(self) -> ta.Mapping[str, GitStatusLine]:
+    def by_b(self) -> ta.Mapping[str, GitStatusItem]:
         return self._by_b
 
     #
@@ -367,11 +367,11 @@ class GitStatus(ta.Sequence[GitStatusLine]):
 
     @property
     def has_staged(self) -> bool:
-        return any(l.x != GitStatusLineState.UNMODIFIED for l in self._lst)
+        return any(l.x != GitStatusState.UNMODIFIED for l in self._lst)
 
     @property
     def has_dirty(self) -> bool:
-        return any(l.y != GitStatusLineState.UNMODIFIED for l in self._lst)
+        return any(l.y != GitStatusState.UNMODIFIED for l in self._lst)
 
 
 def parse_git_status(s: str) -> GitStatus:

{omdev-0.0.0.dev114 → omdev-0.0.0.dev116}/omdev/pip.py

@@ -30,7 +30,7 @@ def lookup_latest_package_version(
         pypi_url: str = DEFAULT_PYPI_URL,
 ) -> str:
     pkg_name = check.non_empty_str(package)
-    with urllib.request.urlopen(f'{pypi_url}rss/project/{pkg_name}/releases.xml') as resp:  # noqa
+    with urllib.request.urlopen(f'{pypi_url.rstrip("/")}/rss/project/{pkg_name}/releases.xml') as resp:  # noqa
         rss = resp.read()
     doc = ET.parse(io.BytesIO(rss))  # noqa
     latest = check.not_none(doc.find('./channel/item/title')).text

{omdev-0.0.0.dev114 → omdev-0.0.0.dev116}/omdev/pycharm/cli.py

@@ -1,6 +1,9 @@
 """
 TODO:
  - PyCharm.app/Contents/plugins/python-ce/helpers/pydev/_pydevd_bundle/pydevd_constants.py -> USE_LOW_IMPACT_MONITORING
+ - DISPLAY=":1" - ls /tmp/.X11-unix/X1 ?
+  - https://unix.stackexchange.com/questions/17255/is-there-a-command-to-list-all-open-displays-on-a-machine
+  - w -oush
 """
 import inspect
 import os.path
@@ -22,20 +25,19 @@ return
 
 
 _LINUX_OPEN_SCRIPT = """
-# Check if PyCharm is already running
-if pgrep -x "pycharm.sh" > /dev/null; then
-    echo "PyCharm is already running. Opening project..."
+# sudo apt install xdotool wmctrl
 
-    # Bring PyCharm to the foreground
-    wmctrl -a "PyCharm"
+# wmctrl -lx
+# 0x03000054  0 jetbrains-pycharm.jetbrains-pycharm  spinlock-ws omlish - cli.py
+# wmctrl -i -a 0x03000054
 
-    # Simulate the keyboard shortcut to open a new project
-    xdotool key --delay 100 ctrl+shift+a
-    xdotool type "$PROJECT_PATH"
+if pgrep -x "pycharm.sh" > /dev/null; then
+    # export DISPLAY=":1"
+    wmctrl -x -a jetbrains-pycharm.jetbrains-pycharm
+    xdotool key --delay 20 alt+f alt+o
+    xdotool type --delay 10 "$(pwd)"
     xdotool key Return
-
 else
-    echo "Starting PyCharm with project..."
     nohup pycharm.sh "$PROJECT_PATH" > /dev/null 2>&1 &
 fi
 """