experimentals

Author: LordAmit

.gitignore

@@ -109,3 +109,6 @@ ENV/
 *.idea*
 
 *.tex
+duplicate.db
+duplicate.sqlite
+Trash

autoclicker/autoclicker/__init__.py

@@ -0,0 +1,96 @@
+import sys
+import time
+
+import pyautogui
+from pyautogui import Point
+
+times_per_second = 20
+delay_between_clicks = 1 / times_per_second
+
+x_offset = 30
+
+
+def __initial_delay(delay: int):
+    time.sleep(delay)
+    print("finished delay")
+
+
+def clicks(click_times: int = 10, delay_before_start: int = 3):
+    global delay_between_clicks
+    if delay_before_start != 0:
+        __initial_delay(delay_before_start)
+
+    start_position: pyautogui.Point = pyautogui.position()
+    for i in range(0, click_times):
+        pyautogui.click()
+        time.sleep(delay_between_clicks)
+        current_position: pyautogui.Point = pyautogui.position()
+        # print("current position = " + str(current_position))
+        # print("start position: " + str(start_position))
+        if current_position != start_position:
+            print("not equal position")
+            break
+
+
+def click_image_mode(delay_before_start: int = 3):
+    __initial_delay(delay_before_start)
+    global x_offset
+    image_abs_path = '/Users/amitseal/git/' \
+                     'automating-boring-tasks-using-python/' \
+                     'autoclicker/autoclicker/images/eye.png'
+
+    try:
+        print("entering while")
+        for i in range(0, 5):
+            print("in while")
+
+            print("trying to find image")
+            start_x = 79
+            end_x = 1346
+            start_y = 152
+            end_y = 871
+            width = end_x - start_x
+            height = end_y - start_y
+            image_location: Point = pyautogui.locateOnScreen(
+                image_abs_path,
+                region=(start_x, width, start_y, height),
+                confidence=0.6)
+            pyautogui.screenshot('img{}.png'.format(str(i)),
+                                 region=(
+                                     start_x, start_y, width * 2, height * 2))
+
+            print("found image!")
+            print(image_location)
+            break
+            continue
+            start_position = Point(image_location.x - x_offset,
+                                   image_location.y)
+            pyautogui.moveTo(start_position, image_location.y)
+            current_position: pyautogui.Point = pyautogui.position()
+            time.sleep(delay_between_clicks)
+            pyautogui.click()
+            if current_position != start_position:
+                print("not equal position")
+                break
+            break
+    except pyautogui.ImageNotFoundException:
+        print("image not found, break")
+
+
+def find_current_position():
+    __initial_delay(2)
+    while True:
+        current = pyautogui.position()
+        print(current)
+        time.sleep(1)
+
+
+if __name__ == '__main__':
+    if len(sys.argv) > 1:
+        print(sys.argv)
+        # exit()
+        clicks(1000, int(sys.argv[1]))
+    else:
+        clicks(1000, 2)
+    # click_image_mode()
+    # find_current_position()

autoclicker/autoclicker/images/eye.png

@@ -0,0 +1,19 @@
+import pyperclip
+
+def main():
+    clip = pyperclip.paste()
+    lines = clip.splitlines()
+    new_lines = ""
+    for line in lines:
+        line = line.replace("[00 --> 00]","")
+        if "->" in line:
+            if "[" in line and "]" in line:
+                line = line[25:]
+            else:
+                continue
+        new_lines += line.replace("\n", " ").replace("  ", " ").replace("’", "'") + " "
+    print(new_lines)
+    pyperclip.copy(new_lines.replace("  ", " "))
+
+if __name__ == "__main__":
+    main()

autoclicker/autoclicker/main.py

@@ -0,0 +1,2 @@
+#!/bin/bash
+/Users/amit/git/automating-boring-tasks-using-python/clipboard_modifier/venv/bin/python /Users/amit/git/automating-boring-tasks-using-python/clipboard_modifier/main.py

clipboard_modifier/__init__.py

@@ -0,0 +1 @@
+/Users/amitseal/git/automating-boring-tasks-using-python/image_sort_landscape_portrait/src/venv/bin/python /Users/amitseal/git/automating-boring-tasks-using-python/image_sort_landscape_portrait/src/main.py

clipboard_modifier/init.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+import time
+import random
+import re
+
+# https://github.com/search?p=4&q=Cipher.getInstance&type=Code
+
+class IterSearch():
+    def __init__(self) -> None:
+        
+        self.matched_urls: list[str] = []
+        self.url_search: str = "https://github.com/search?p=P@#&q=Cipher.getInstance&type=Code"
+        self.token_iter: str = "P@#"
+        self.iter_start: int = 4
+        self.iter_end: int = 10
+        self.token_keyword: str = None
+        self.expressions
+        self.pause_seconds: int = None
+        self.random_delay: list[int] = (5, 10)
+
+    # "Cipher\.getInstance\(\"[A-Z]+\"\)"
+    def add_expression(self, expression):
+        self.expressions.add(expression)
+
+    def _append_matched_url(self, URL: str):
+        self.matched_urls.append(URL) 
+
+    def _adding_pause(self):
+        delay = random.randint(self.random_delay[0], self.random_delay[1])
+        time.sleep(delay)
+
+    def iter_url(self):
+        # including the iter_end itself
+        for i in range(self.iter_start, self.iter_end+1):
+            self._adding_pause()
+            formatted_URL: str = self.url_search.replace(
+                self.token_iter, 
+                str(i)
+                ).replace(
+                    self.token_keyword, 
+                    self.keyword)
+            content = self._get_content_from_url(formatted_URL)
+            if self._find_word_in_content(content, self.keyword):
+                self._append_matched_url(formatted_URL)
+
+    def _get_content_from_url(self, URL: str) -> str:
+        return None
+    
+    def _find_expression_in_content(self, content: str):
+        for expression in self.expressions:
+            return re.findall(pattern, content)
+
+
+if __name__ == "__main__":
+    pass

clipboard_modifier/main.py

@@ -0,0 +1,144 @@
+import argparse
+import re
+from typing import List
+from enum import Enum
+import random
+
+
+classes_used = 0
+
+class LineType(Enum):
+    TEXT = 1
+    HEADER = 2
+    ITEM = 3
+
+all_class_names = [
+    "dangerm",
+    "errorm",
+    "hintm",
+    "tipm",
+    "notem",
+    "seealsom",
+    "todom"]
+
+
+Classes = {}
+
+
+def reset_classes():
+    global Classes
+    global classes_used
+    classes_used = 0
+    for i in range(0,len(all_class_names)):
+        Classes[i] = (all_class_names[i], False)
+
+def class_supplier():
+    global Classes
+    global classes_used
+    random_int = 0
+    if classes_used == len(all_class_names)-1:
+        reset_classes()
+    while True:
+        random_int = random.randint(0, len(Classes.keys())-1)
+        if Classes[random_int][1]:
+            continue
+        else:
+            Classes[random_int] = (Classes[random_int][0], True)
+            classes_used += 1
+            return Classes[random_int][0]
+
+def read_file(file_path:str):
+    lines = []
+    with open(file_path) as file:
+        lines = file.readlines()
+    return lines
+
+def find_indent_spaces(line:str):
+    return len(line) - len(line.lstrip())
+
+def line_type(line:str) ->LineType:
+    if line.strip().startswith("#"):
+        return LineType.HEADER
+    if line.strip().startswith("-"):
+        return LineType.ITEM
+    else:
+        return LineType.TEXT
+
+def process_item(current_line: str, lines: str, current_index: int):
+    length = len(lines)
+    if length < 2:
+        return current_line
+    splitted = current_line.lstrip().split(" ", maxsplit=1)
+    content = splitted[0].replace("-","") + " "+splitted[1]
+    content = content.strip()
+    next_index = current_index + 1
+    next_line_indent_level = 0
+    current_line_indent_level = 0
+    if next_index < length:
+        next_line:str = lines[next_index]
+        current_line_indent_level = find_indent_spaces(current_line)
+        next_line_indent_level = find_indent_spaces(next_line)
+    if next_line_indent_level > current_line_indent_level:
+        return "<details class = '{}'>\n<summary>".format(class_supplier())+content+"</summary>"
+
+    else:
+        return content
+
+def is_continuous(line: str, previous_line:str) -> bool:
+    if len(previous_line.strip()) == 0:
+        return False
+    else:
+        return True
+
+
+def process_header(line_header: str, is_this_first_header_seen: bool = False):
+    content = line_header.replace("#", "").strip()
+    if is_this_first_header_seen:
+        return "\n<details class = '{}'>\n<summary>".format(class_supplier())+content+"</summary>"
+    else:
+        return "</details>"+\
+            "\n<details class = '{}'>\n<summary>".format(class_supplier())+content+"</summary>"
+
+
+def process_lines(lines: List[str]):
+    new_lines = []
+    current_indent = 0
+    previous_indent = 0
+    heading_first: bool = False
+    current_line_type: LineType = LineType.TEXT
+    previous_line_type: LineType = LineType.TEXT
+    current_line:str = ""
+    is_this_first_header_seen: bool = True
+    is_processing_item = False
+    is_processing_header = False
+    length = len(lines)
+    for i in range(0, len(lines)):
+        current_line = lines[i]
+        if len(current_line.strip()) < 1:
+            if is_processing_item:
+                is_processing_item = False
+                new_lines.append("</details>")
+            new_lines.append(current_line)
+            continue
+        if line_type(current_line) == LineType.HEADER:
+            is_processing_header = True
+            new_lines.append(process_header(current_line, is_this_first_header_seen))
+            is_this_first_header_seen = False
+        elif line_type(current_line) == LineType.ITEM:
+            new_lines.append(process_item(current_line, lines, i))
+            is_processing_item = True
+        else:
+            new_lines.append(current_line.strip())
+    new_lines.append("</details>")
+    return new_lines
+
+def write_file(lines: List[str], filename):
+    with open(filename, "w") as file:
+        for line in lines:
+            file.write(line+"\n")
+
+reset_classes()
+
+write_file(
+    process_lines(
+        read_file("source.md")), "output.html")