pyflowlauncher 0.1.0.dev0__tar.gz → 0.3.0.dev0__tar.gz

{pyflowlauncher-0.1.0.dev0 → pyflowlauncher-0.3.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyflowlauncher
-Version: 0.1.0.dev0
+Version: 0.3.0.dev0
 Summary: Python library to help build Flow Launcher plugins.
 Author-email: William McAllister <dev.garulf@gmail.com>
 License: MIT

pyflowlauncher-0.3.0.dev0/pyflowlauncher/manifest.py

@@ -0,0 +1,25 @@
+from typing import TypedDict, Literal
+
+MANIFEST_FILE = 'plugin.json'
+
+Languages = Literal[
+    'Python',
+    'CSharp',
+    'FSharp',
+    'Executable',
+    'TypeScript',
+    'JavaScript',
+]
+
+
+class PluginManifestSchema(TypedDict):
+    ID: str
+    ActionKeyword: str
+    Name: str
+    Description: str
+    Author: str
+    Version: str
+    Language: Languages
+    Website: str
+    IcoPath: str
+    ExecuteFileName: str

{pyflowlauncher-0.1.0.dev0 → pyflowlauncher-0.3.0.dev0}/pyflowlauncher/plugin.py

@@ -1,13 +1,17 @@
 from __future__ import annotations
 
+import sys
 from functools import wraps
 from typing import Any, Callable, Iterable, Union
+from pathlib import Path
+import json
 
 from pyflowlauncher.shared import logger
 
 from .event import EventHandler
 from .jsonrpc import JsonRPCClient
 from .result import JsonRPCAction, ResultResponse
+from .manifest import PluginManifestSchema, MANIFEST_FILE
 
 Method = Callable[..., Union[ResultResponse, JsonRPCAction]]
 
@@ -54,3 +58,13 @@ class Plugin:
         if 'result' in feedback and self._settings is not None:
             feedback['SettingsChange'] = self.settings
         self._client.send(feedback)
+
+    def plugin_root_dir(self) -> Path:
+        """Return the root directory of the plugin."""
+        return Path(sys.argv[0]).parent
+
+    def manifest(self) -> PluginManifestSchema:
+        """Return the plugin manifest."""
+        with open(self.plugin_root_dir() / MANIFEST_FILE, 'r', encoding='utf-8') as f:
+            manifest = json.load(f)
+        return manifest

pyflowlauncher-0.3.0.dev0/pyflowlauncher/string_matcher.py

@@ -0,0 +1,222 @@
+from dataclasses import dataclass, field
+from typing import List
+
+SPACE_CHAR: str = ' '
+QUERY_SEARCH_PRECISION = {
+    'Regular': 50,
+    'Low': 20,
+    'None': 0
+}
+DEFAULT_QUERY_SEARCH_PRECISION = QUERY_SEARCH_PRECISION['Regular']
+
+"""
+This is a python copy of Flow Launcher's string matcher.
+I take no credit for the algorithm, I just translated it to python.
+"""
+
+
+@dataclass
+class MatchData:
+    """Match data"""
+    matched: bool
+    score_cutoff: int
+    index_list: List[int] = field(default_factory=list)
+    score: int = 0
+
+
+def string_matcher(query: str, text: str, ignore_case: bool = True,
+                   query_search_precision: int = DEFAULT_QUERY_SEARCH_PRECISION) -> MatchData:
+    """Compare query to text"""
+    if not text or not query:
+        return MatchData(False, query_search_precision)
+
+    query = query.strip()
+
+    current_acronym_query_index = 0
+    acronym_match_data: List[int] = []
+    acronyms_total_count: int = 0
+    acronyms_matched: int = 0
+
+    full_text_lower: str = text.lower() if ignore_case else text
+    query_lower: str = query.lower() if ignore_case else query
+
+    query_substrings: List[str] = query_lower.split(' ')
+    current_query_substring_index: int = 0
+    current_query_substring = query_substrings[current_query_substring_index]
+    current_query_substring_char_index = 0
+
+    first_match_index = -1
+    first_match_index_in_word = -1
+    last_match_index = 0
+    all_query_substrings_matched: bool = False
+    match_found_in_previous_loop: bool = False
+    all_substrings_contained_in_text: bool = True
+
+    index_list: List[int] = []
+    space_indices: List[int] = []
+    for text_index in range(len(full_text_lower)):
+        if (current_acronym_query_index >= len(query_lower) or
+                (current_acronym_query_index >= len(query_lower) and all_query_substrings_matched)):
+            break
+
+        if full_text_lower[text_index] == SPACE_CHAR and current_query_substring_char_index == 0:
+            space_indices.append(text_index)
+
+        if is_acronym(text, text_index):
+            if full_text_lower[text_index] == query_lower[current_acronym_query_index]:
+                acronym_match_data.append(text_index)
+                acronyms_matched += 1
+                current_acronym_query_index += 1
+
+        if is_acronym_count(text, text_index):
+            acronyms_total_count += 1
+
+        if all_query_substrings_matched or (full_text_lower[text_index]
+                                            != current_query_substring[current_query_substring_char_index]):
+            match_found_in_previous_loop = False
+            continue
+
+        if first_match_index < 0:
+            first_match_index = text_index
+
+        if current_query_substring_char_index == 0:
+            match_found_in_previous_loop = True
+            first_match_index_in_word = text_index
+        elif not match_found_in_previous_loop:
+            start_index_to_verify = text_index - current_query_substring_char_index
+
+            if all_previous_chars_matched(start_index_to_verify, current_query_substring_char_index, full_text_lower,
+                                          current_query_substring):
+                match_found_in_previous_loop = True
+                first_match_index_in_word = start_index_to_verify if current_query_substring_index == 0 else first_match_index
+
+                index_list = get_updated_index_list(
+                    start_index_to_verify, current_query_substring_char_index, first_match_index_in_word, index_list)
+
+        last_match_index = text_index + 1
+        index_list.append(text_index)
+
+        current_query_substring_char_index += 1
+
+        if current_query_substring_char_index == len(current_query_substring):
+            all_substrings_contained_in_text = match_found_in_previous_loop and all_substrings_contained_in_text
+
+            current_query_substring_index += 1
+
+            all_query_substrings_matched = all_query_substrings_matched_func(
+                current_query_substring_index, len(query_substrings))
+
+            if all_query_substrings_matched:
+                continue
+
+            current_query_substring = query_substrings[current_query_substring_index]
+            current_query_substring_char_index = 0
+
+    if acronyms_matched > 0 and acronyms_matched == len(query):
+        acronyms_score: int = int(acronyms_matched * 100 / acronyms_total_count)
+
+        if acronyms_score >= query_search_precision:
+            return MatchData(True, query_search_precision, acronym_match_data, acronyms_score)
+
+    if all_query_substrings_matched:
+
+        nearest_space_index = calculate_closest_space_index(
+            space_indices, first_match_index)
+
+        score = calculate_search_score(query, text, first_match_index - nearest_space_index - 1,
+                                       space_indices, last_match_index - first_match_index, all_substrings_contained_in_text)
+
+        return MatchData(True, query_search_precision, index_list, score)
+
+    return MatchData(False, query_search_precision)
+
+
+def calculate_search_score(query: str, text: str, first_index: int, space_indices: List[int],
+                           match_length: int, all_substrings_contained_in_text: bool):
+    score = 100 * (len(query) + 1) / ((1 + first_index) + (match_length + 1))
+
+    if first_index == 0 and all_substrings_contained_in_text:
+        score -= len(space_indices)
+
+    if (len(text) - len(query)) < 5:
+        score += 20
+    elif (len(text) - len(query)) < 10:
+        score += 10
+
+    if all_substrings_contained_in_text:
+        count: int = len(query.replace(' ', ''))
+        threshold: int = 4
+        if count <= threshold:
+            score += count * 10
+        else:
+            score += threshold * 10 + (count - threshold) * 5
+
+    return score
+
+
+def get_updated_index_list(start_index_to_verify: int,
+                           current_query_substring_char_index: int,
+                           first_matched_index_in_word: int, index_list: List[int]):
+    updated_list: List[int] = []
+
+    for idx, item in enumerate(index_list):
+        if item >= first_matched_index_in_word:
+            index_list.pop(idx)
+
+    updated_list.extend(index_list)
+
+    for i in range(current_query_substring_char_index):
+        updated_list.append(start_index_to_verify + i)
+
+    return updated_list
+
+
+def all_query_substrings_matched_func(current_query_substring_index: int, query_substrings_length: int) -> bool:
+    return current_query_substring_index >= query_substrings_length
+
+
+def all_previous_chars_matched(start_index_to_verify: int,
+                               current_query_substring_char_index: int,
+                               full_text_lower: str, current_query_substring: str) -> bool:
+    all_match = True
+    for i in range(current_query_substring_char_index):
+        if full_text_lower[start_index_to_verify + i] != current_query_substring[i]:
+            all_match = False
+
+    return all_match
+
+
+def is_acronym(text: str, text_index: int) -> bool:
+    if is_acronym_char(text, text_index) or is_acronym_number(text, text_index):
+        return True
+    return False
+
+
+def is_acronym_count(text: str, text_index: int) -> bool:
+    if is_acronym_char(text, text_index):
+        return True
+    if is_acronym_number(text, text_index):
+        return text_index == 0 or text[text_index - 1] == SPACE_CHAR
+
+    return False
+
+
+def is_acronym_char(text: str, text_index: int) -> bool:
+    return text[text_index].isupper() or text_index == 0 or text[text_index - 1] == SPACE_CHAR
+
+
+def is_acronym_number(text: str, text_index: int) -> bool:
+    return text[text_index].isdigit()
+
+
+def calculate_closest_space_index(space_indices: List[int], first_match_index: int) -> int:
+
+    closest_space_index = -1
+
+    for i in space_indices:
+        if i < first_match_index:
+            closest_space_index = i
+        else:
+            break
+
+    return closest_space_index

{pyflowlauncher-0.1.0.dev0 → pyflowlauncher-0.3.0.dev0}/pyflowlauncher.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyflowlauncher
-Version: 0.1.0.dev0
+Version: 0.3.0.dev0
 Summary: Python library to help build Flow Launcher plugins.
 Author-email: William McAllister <dev.garulf@gmail.com>
 License: MIT

{pyflowlauncher-0.1.0.dev0 → pyflowlauncher-0.3.0.dev0}/pyflowlauncher.egg-info/SOURCES.txt

@@ -6,10 +6,12 @@ pyflowlauncher/api.py
 pyflowlauncher/event.py
 pyflowlauncher/icons.py
 pyflowlauncher/jsonrpc.py
+pyflowlauncher/manifest.py
 pyflowlauncher/method.py
 pyflowlauncher/plugin.py
 pyflowlauncher/result.py
 pyflowlauncher/shared.py
+pyflowlauncher/string_matcher.py
 pyflowlauncher.egg-info/PKG-INFO
 pyflowlauncher.egg-info/SOURCES.txt
 pyflowlauncher.egg-info/dependency_links.txt

{pyflowlauncher-0.1.0.dev0 → pyflowlauncher-0.3.0.dev0}/pyproject.toml

@@ -6,7 +6,7 @@ name = "pyflowlauncher"
 authors = [
     {name = "William McAllister", email = "dev.garulf@gmail.com"}
 ]
-version = '0.1.0-dev.0'
+version = '0.3.0-dev.0'
 description = "Python library to help build Flow Launcher plugins."
 readme = "README.md"
 requires-python = ">=3.8"
@@ -24,7 +24,7 @@ dependencies = [
 packages = ["pyflowlauncher"]
 
 [tool.bumpversion]
-current_version = "0.1.0-dev.0"
+current_version = "0.3.0-dev.0"
 parse = """(?x)
     (?P<major>[0-9]+)
     \\.(?P<minor>[0-9]+)