abstract-windows 0.0.1__tar.gz

abstract_windows-0.0.1/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: abstract_windows
+Version: 0.0.1
+Home-page: https://github.com/AbstractEndeavors/abstract_windows
+Author: putkoff
+Author-email: partners@abstractendeavors.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: abstract_utilities
+Requires-Dist: abstract_webserver
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+
+# Unknown Package (vUnknown Version)
+
+No description available
+
+## Installation
+
+```bash
+pip install Unknown Package
+```
+
+## Dependencies
+
+None
+
+## Modules
+
+### src/abstract_react/replace_utils.py
+
+Description of script based on prompt: You are analyzing a Python script 'replace_utils.p (mock response)
+
+### src/abstract_react/__init__.py
+
+Description of script based on prompt: You are analyzing a Python script '__init__.py' lo (mock response)
+
+### src/abstract_react/import_utils.py
+
+Description of script based on prompt: You are analyzing a Python script 'import_utils.py (mock response)
+
+### src/__init__.py
+
+Description of script based on prompt: You are analyzing a Python script '__init__.py' lo (mock response)
+
+### src/abstract_react/utils.py
+
+Description of script based on prompt: You are analyzing a Python script 'utils.py' locat (mock response)
+
+### src/abstract_react/abstract_react.py
+
+Description of script based on prompt: You are analyzing a Python script 'abstract_react. (mock response)
+

abstract_windows-0.0.1/README.md

@@ -0,0 +1,40 @@
+# Unknown Package (vUnknown Version)
+
+No description available
+
+## Installation
+
+```bash
+pip install Unknown Package
+```
+
+## Dependencies
+
+None
+
+## Modules
+
+### src/abstract_react/replace_utils.py
+
+Description of script based on prompt: You are analyzing a Python script 'replace_utils.p (mock response)
+
+### src/abstract_react/__init__.py
+
+Description of script based on prompt: You are analyzing a Python script '__init__.py' lo (mock response)
+
+### src/abstract_react/import_utils.py
+
+Description of script based on prompt: You are analyzing a Python script 'import_utils.py (mock response)
+
+### src/__init__.py
+
+Description of script based on prompt: You are analyzing a Python script '__init__.py' lo (mock response)
+
+### src/abstract_react/utils.py
+
+Description of script based on prompt: You are analyzing a Python script 'utils.py' locat (mock response)
+
+### src/abstract_react/abstract_react.py
+
+Description of script based on prompt: You are analyzing a Python script 'abstract_react. (mock response)
+

abstract_windows-0.0.1/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

abstract_windows-0.0.1/setup.cfg

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

abstract_windows-0.0.1/setup.py

@@ -0,0 +1,34 @@
+from time import time
+import setuptools
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+setuptools.setup(
+    name='abstract_windows',
+    version='0.0.1',
+    author='putkoff',
+    author_email='partners@abstractendeavors.com',
+    description="",
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    url='https://github.com/AbstractEndeavors/abstract_windows',
+    classifiers=[
+        'Development Status :: 3 - Alpha',
+        'Intended Audience :: Developers',
+        'Topic :: Software Development :: Libraries',
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
+    ],
+    install_requires=['abstract_utilities','abstract_webserver'],
+    package_dir={"": "src"},
+    packages=setuptools.find_packages(where="src"),
+    python_requires=">=3.6",
+    # Add this line to include wheel format in your distribution
+    setup_requires=['wheel'],
+)

abstract_windows-0.0.1/src/abstract_windows/__init__.py

@@ -0,0 +1,3 @@
+from .browser_utils import *
+from .window_utils import *
+from .string_comp import *

abstract_windows-0.0.1/src/abstract_windows/browser_utils/__init__.py

@@ -0,0 +1 @@
+from .browser_utils import *

abstract_windows-0.0.1/src/abstract_windows/browser_utils/browser_utils.py

@@ -0,0 +1,66 @@
+import subprocess
+import time
+from typing import List
+from ..string_comp import *
+from ..window_utils import *
+# tweak if your browser uses Page_Down instead of Tab
+NEXT_TAB_KEY = "ctrl+Tab"
+# how many times to press before giving up
+MAX_TABS = 50
+# time for browser to update title
+DELAY = 0.1
+# Browser title signatures
+BROWSER_PATTERNS = [
+    'Mozilla', 'Firefox', 'Chrome', 'Chromium',
+    'Microsoft Edge', 'Opera', 'Safari'
+]
+def is_browser(win):
+    if get_strings_in_string(win.get('window_title'),BROWSER_PATTERNS):
+        return True
+    return False
+
+def get_tab_titles(win):
+    win_id = win["window_id"]
+    tab_titles = cycle_tabs(win_id)
+    win['tab_titles'] = tab_titles
+    return win
+
+def get_browsers(parsed_windows=None,active_windows=None):
+    parsed_windows = parsed_windows or get_parsed_windows()
+    browsers = [get_tab_titles(parsed_window) for parsed_window in parsed_windows if is_browser(parsed_window)]
+    return browsers
+
+def activate_window(win_id: str):
+    subprocess.run(["xdotool", "windowactivate", "--sync", win_id], check=True)
+
+def get_window_title(win_id: str) -> str:
+    res = subprocess.run(
+        ["xdotool", "getwindowname", win_id],
+        capture_output=True, text=True, check=True
+    )
+    return res.stdout.strip()
+
+def switch_tab(win_id: str):
+    # sends the next‐tab key only to that window
+    subprocess.run(
+        ["xdotool", "key", "--window", win_id, NEXT_TAB_KEY],
+        check=True
+    )
+
+def cycle_tabs(win_id: str,window_name=None) -> List[str]:
+    """Returns the ordered list of tab-titles in the given window."""
+    activate_window(win_id)
+    first_title = get_window_title(win_id)
+    titles = [first_title]
+
+    for _ in range(MAX_TABS):
+        switch_tab(win_id)
+        time.sleep(DELAY)
+        title = get_window_title(win_id)
+        if window_name and title == window_name:
+            return 
+        if title == first_title:
+            break
+        titles.append(title)
+
+    return titles

abstract_windows-0.0.1/src/abstract_windows/string_comp/__init__.py

@@ -0,0 +1 @@
+from .string_compare import *

abstract_windows-0.0.1/src/abstract_windows/string_comp/string_compare.py

@@ -0,0 +1,103 @@
+from abstract_utilities import make_list
+def get_strings_in_string(string,strings):
+    for comp_string in strings:
+        if comp_string.lower() in string.lower():
+            return True
+    return False
+def find_longest_common_substring(string, comp_string):
+    # Find the longest common substring
+    min_len = min(len(string), len(comp_string))
+    for length in range(min_len, 0, -1):
+        for i in range(len(string) - length + 1):
+            substring = string[i:i + length]
+            if substring in comp_string:
+                return substring
+    return None
+
+def get_string_confidence(string,string_remains):
+    string_len = len(string)
+    remains_str = ''.join(string_remains)
+    remains_len = len(remains_str)
+    remains_perc = 0
+    confidence = 1
+    if remains_len:
+        remains_perc = remains_len/string_len
+        confidence = 1 - remains_perc
+    return confidence
+def remove_substring(string, substring):
+    # Remove the first occurrence of substring and return remaining parts
+    idx = string.find(substring)
+    if idx == -1:
+        return [string]
+    remains = [string[:idx], string[idx + len(substring):]]
+    return [r for r in remains if r]  # Remove empty strings
+
+def compare_strings(string, comp_string):
+    results = []
+    
+    # Initialize with the original strings
+    current_strings = [(string, comp_string)]
+    
+    while current_strings:
+        new_strings = []
+        for s, cs in current_strings:
+            # Find the longest common substring
+            common = find_longest_common_substring(s, cs)
+            if not common:
+                continue  # No common substring, move to next pair
+            
+            # Record the found substring and remaining parts
+            string_remains = remove_substring(s, common)
+            comp_string_remains = remove_substring(cs, common)
+            
+            # Store the result
+            results.append({
+                "found": common,
+                "string": {"remains": string_remains},
+                "comp_string": {"remains": comp_string_remains}
+            })
+            
+            # Add remaining parts for further processing
+            for sr in string_remains:
+                for csr in comp_string_remains:
+                    new_strings.append((sr, csr))
+        
+        current_strings = new_strings
+    string_remains = results[-1].get('string',{}).get('remains')
+    string_confidence = get_string_confidence(string,string_remains)
+    comp_string_remains = results[-1].get('comp_string',{}).get('remains')
+    comp_string_confidence = get_string_confidence(comp_string,comp_string_remains)
+    results = {"string":string,
+               "comp_string":comp_string,
+               "results":results,
+               "found":[result['found'] for result in results if result],
+               "confidence":{
+                   "string":string_confidence,
+                   "comp_string":comp_string_confidence
+                   }
+               }
+    return results
+
+def return_best_comp_strings(string, comp_strings):
+    results = []
+    comp_strings = make_list(comp_strings)
+    for comp_string in comp_strings:
+        result = compare_strings(string, comp_string)
+        results.append(result)
+    
+    confidence_results = None
+    for i, result in enumerate(results):
+        confidence = result.get('confidence', {})
+        string_confidence = confidence.get('string', 0)
+        comp_string_confidence = confidence.get('comp_string', 0)
+        if confidence_results is None:
+            #if string_confidence>.70:
+                confidence_results = [string_confidence, comp_string_confidence, i]
+        elif string_confidence > confidence_results[0]:
+            confidence_results = [string_confidence, comp_string_confidence, i]
+        elif string_confidence == confidence_results[0]:
+            if comp_string_confidence > confidence_results[1]:
+                confidence_results = [string_confidence, comp_string_confidence, i]
+    
+    return comp_strings[confidence_results[2]]
+

abstract_windows-0.0.1/src/abstract_windows/window_utils/__init__.py

@@ -0,0 +1 @@
+from .window_utils import *

abstract_windows-0.0.1/src/abstract_windows/window_utils/window_utils.py

@@ -0,0 +1,183 @@
+from typing import List, Dict, Optional, Union, Callable
+import threading
+import re
+import subprocess
+from Xlib import X, display
+from Xlib.ext import randr
+from difflib import get_close_matches
+XRANDR_CMD     = ["xrandr"]  # or ["xrandr", "--listmonitors"] if you prefer
+WMCTRL_LIST_CMD = ['wmctrl', '-l', '-p']
+WMCTRL_MOVE_CMD = ['wmctrl', '-i', '-r']
+XDOTOOL_GEOMETRY_CMD = ['xdotool', 'getwindowgeometry']
+
+# Regex patterns
+
+MONITOR_REGEX  = re.compile(
+    r"""^
+    (?P<name>\S+)\s+             # e.g. "DisplayPort-1-2"
+    connected                     # literal word
+    (?:\s+primary)?               # optional " primary"
+    \s+
+    (?P<width>\d+)x(?P<height>\d+)  # resolution, e.g. "2560x1440"
+    \+(?P<x>\d+)\+(?P<y>\d+)        # offsets, e.g. "+0+0"
+    """,
+    re.VERBOSE
+)
+
+POSITION_REGEX = re.compile(r'Position:\s+(\d+),(\d+)')
+GEOMETRY_REGEX = re.compile(r'Geometry:\s+(\d+)x(\d+)')
+
+
+
+
+
+
+def get_monitors():
+    monitors = []
+    try:
+        result = subprocess.run(
+            XRANDR_CMD, capture_output=True, text=True, check=True
+        )
+        for line in result.stdout.splitlines():
+            m = MONITOR_REGEX.search(line)
+            if not m:
+                continue
+            gd = m.groupdict()
+            monitors.append({
+                "name":   gd["name"],
+                "x":      int(gd["x"]),
+                "y":      int(gd["y"]),
+                "width":  int(gd["width"]),
+                "height": int(gd["height"]),
+            })
+    except subprocess.SubprocessError as e:
+        print(f"Error running xrandr: {e}")
+    return monitors
+
+
+
+def get_strings_in_string(string,strings):
+    for comp_string in strings:
+        if comp_string.lower() in string.lower():
+            return True
+    return False
+def get_windows_list():
+    result = subprocess.run(
+                WMCTRL_LIST_CMD, capture_output=True, text=True, check=True
+            )
+    windows = result.stdout.splitlines()
+    return windows
+def get_filters(
+    windows: List[str],
+    find_window_id: Optional[str] = None,
+    find_desktop: Optional[str] = None,
+    find_pid: Optional[str] = None,
+    find_host: Optional[str] = None,
+    find_window_title: Optional[str] = None
+):
+    filters = {k: v for k, v in {
+        'window_id': find_window_id,
+        'desktop': find_desktop,
+        'pid': find_pid,
+        'host': find_host,
+        'window_title': find_window_title
+    }.items() if v is not None}
+    return filters
+
+
+def get_monitor_for_window(
+    window_id: Optional[str] = None,
+    x: Optional[int] = None,
+    y: Optional[int] = None
+) -> Dict[str, Union[str, int]]:
+    """Determine which monitor a given window (or coordinate) is on."""
+
+    if window_id and x is None and y is None:
+        geom = get_window_geometry(window_id = window_id)
+        if geom is None:
+            return {}
+        x, y = geom['x'], geom['y']
+
+    if x is None or y is None:
+        return {}
+    for mon in get_monitors():
+        if mon['x'] <= x < mon['x'] + mon['width'] and \
+           mon['y'] <= y < mon['y'] + mon['height']:
+            return {
+                'monitor_name': mon['name'],
+                'monitor_details': f"{mon['width']}x{mon['height']}+{mon['x']}+{mon['y']}",
+                'win_x': x,
+                'win_y': y
+            }
+    return {}
+def parse_window(window):
+    parts = window.split(None, 4)
+    if len(parts) >= 5:
+        win_id, desktop, pid, host, title = parts
+        monitor_info = get_monitor_for_window(window_id=win_id)
+        window_geometry = get_window_geometry(window_id=win_id)
+        info = {
+            'window_id': win_id, 'desktop': desktop, 'pid': pid,
+            'host': host, 'window_title': title,'monitor_info':monitor_info,
+            'window_geometry':window_geometry
+        }
+        
+        info.update(monitor_info)
+        return info
+def filter_window(info,filters={}):
+    if filters and all(parsed_window[k] == v for k, v in filters.items()):
+        return info 
+def parse_windows(windows,filters={}):
+    parsed_windows = []
+    for window in windows:
+        parsed_window = parse_window(window)
+        filtered_window = filter_window(parsed_window,filters=filters)
+        if filtered_window:
+            return filtered_window
+        if parsed_window:
+            parsed_windows.append(parsed_window)
+    return parsed_windows
+def get_window_items(
+    windows: List[str],
+    find_window_id: Optional[str] = None,
+    find_desktop: Optional[str] = None,
+    find_pid: Optional[str] = None,
+    find_host: Optional[str] = None,
+    find_window_title: Optional[str] = None
+) -> Union[Dict[str, str], List[Dict[str, str]]]:
+    """Parse `wmctrl -l -p` output, optionally filtering."""
+    filters = get_filters(
+        windows=windows,
+        find_window_id= find_window_id,
+        find_desktop= find_desktop,
+        find_pid= find_pid,
+        find_host= find_host,
+        find_window_title= find_window_title
+        )
+    parsed = parse_windows(windows,filters)
+    return parsed
+def get_window_geometry(window_id: str) -> Optional[Dict[str, int]]:
+    """Get window position (x, y) and size (width, height) using xdotool."""
+    try:
+        result = subprocess.run(
+            XDOTOOL_GEOMETRY_CMD + [window_id],
+            capture_output=True, text=True, check=True
+        )
+        pos_m = POSITION_REGEX.search(result.stdout)
+        size_m = GEOMETRY_REGEX.search(result.stdout)
+        if pos_m and size_m:
+            return {
+                'x': int(pos_m.group(1)),
+                'y': int(pos_m.group(2)),
+                'width': int(size_m.group(1)),
+                'height': int(size_m.group(2))
+            }
+        return None
+    except subprocess.SubprocessError as e:
+        print(f"Error getting geometry: {e}")
+        return None
+def get_parsed_windows():
+    windows = get_windows_list()
+    filters = get_filters(windows=windows)
+    parsed_windows = parse_windows(windows=windows,filters=filters)
+    return parsed_windows

abstract_windows-0.0.1/src/abstract_windows.egg-info/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: abstract_windows
+Version: 0.0.1
+Home-page: https://github.com/AbstractEndeavors/abstract_windows
+Author: putkoff
+Author-email: partners@abstractendeavors.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: abstract_utilities
+Requires-Dist: abstract_webserver
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+
+# Unknown Package (vUnknown Version)
+
+No description available
+
+## Installation
+
+```bash
+pip install Unknown Package
+```
+
+## Dependencies
+
+None
+
+## Modules
+
+### src/abstract_react/replace_utils.py
+
+Description of script based on prompt: You are analyzing a Python script 'replace_utils.p (mock response)
+
+### src/abstract_react/__init__.py
+
+Description of script based on prompt: You are analyzing a Python script '__init__.py' lo (mock response)
+
+### src/abstract_react/import_utils.py
+
+Description of script based on prompt: You are analyzing a Python script 'import_utils.py (mock response)
+
+### src/__init__.py
+
+Description of script based on prompt: You are analyzing a Python script '__init__.py' lo (mock response)
+
+### src/abstract_react/utils.py
+
+Description of script based on prompt: You are analyzing a Python script 'utils.py' locat (mock response)
+
+### src/abstract_react/abstract_react.py
+
+Description of script based on prompt: You are analyzing a Python script 'abstract_react. (mock response)
+

abstract_windows-0.0.1/src/abstract_windows.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+setup.py
+src/abstract_windows/__init__.py
+src/abstract_windows.egg-info/PKG-INFO
+src/abstract_windows.egg-info/SOURCES.txt
+src/abstract_windows.egg-info/dependency_links.txt
+src/abstract_windows.egg-info/requires.txt
+src/abstract_windows.egg-info/top_level.txt
+src/abstract_windows/browser_utils/__init__.py
+src/abstract_windows/browser_utils/browser_utils.py
+src/abstract_windows/string_comp/__init__.py
+src/abstract_windows/string_comp/string_compare.py
+src/abstract_windows/window_utils/__init__.py
+src/abstract_windows/window_utils/window_utils.py

abstract_windows-0.0.1/src/abstract_windows.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

abstract_windows-0.0.1/src/abstract_windows.egg-info/requires.txt

@@ -0,0 +1,2 @@
+abstract_utilities
+abstract_webserver

abstract_windows-0.0.1/src/abstract_windows.egg-info/top_level.txt

@@ -0,0 +1 @@
+abstract_windows