Merge branch 'main' of https://git.myitr.org/Jukebox/jukebox-software

# Conflicts:
#	.gitignore
#	read_datasheet.py

.gitignore

@@ -1,9 +1,18 @@
+# python
 venv
 __pycache__
+# cable data folder(s)
 cables
+cables-sample.zip
+# meilisearch (mainly where I've put the data volume for the container)
+meili_data
+# IDE things
 .vscode
-output.log
+.idea
+# videos
 *.webm
 output.mp4
+# log files
 output.log
-cables-sample.zip
+# images
+*.png

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:latest
+
+RUN apt-get update && apt-get install -y libgl1-mesa-glx ghostscript && apt-get clean && rm -rf /var/lib/apt/lists
+COPY . .
+#COPY config-server.yml config.yml
+RUN pip3 install -r requirements.txt
+
+CMD ["python3", "run.py"]
+EXPOSE 5000
+EXPOSE 8000
+EXPOSE 9000

compose.yml

@@ -0,0 +1,13 @@
+services:
+  meilisearch:
+    image: "getmeili/meilisearch:v1.6.2"
+    ports:
+      - "7700:7700"
+    environment:
+      MEILI_MASTER_KEY: fluffybunnyrabbit
+      MEILI_NO_ANALYTICS: true
+    volumes:
+      - "meili_data:/meili_data"
+
+volumes:
+  meili_data:

config.yml

@@ -32,13 +32,13 @@ led:
       ledstart: 288
       ledend: 431
       mode: rgb
-    - universe: 1
-      ip: 192.168.68.130
+    - universe: 4
+      ip: 192.168.5.40
       ledstart: 432
       ledend: 575
       mode: rgb
-    - universe: 4
-      ip: 192.168.68.131
+    - universe: 1
+      ip: 192.168.5.4
       ledstart: 576
       ledend: 719
       mode: rgb
@@ -159,7 +159,7 @@ led:
       size: 24
       diameter: 63.5
       angle: 0
-      pos: [-65.936, 114.3]
+      pos: [-65.991, 114.3]
     - type: circle
       start: 336
       size: 24
@@ -420,6 +420,116 @@ led:
       size: 70
       length: 600
       angle: 270 # down
-      pos: [300, 300]
-
+      pos: [375, 300]
 
+global_position_offset: [0,0] # default coordinate spce below as center of arm at 0,0 - adjust if necessary
+animation_time: 40
+position_map:
+  - index: 0
+    pos: [-152.4, 263.965]
+  - index: 1
+    pos: [-76.2, 263.965]
+  - index: 2
+    pos: [0, 263.965]
+  - index: 3
+    pos: [76.2, 263.965]
+  - index: 4
+    pos: [152.4, 263.965]
+  - index: 5
+    pos: [-190.5, 197.973]
+  - index: 6
+    pos: [-114.3, 197.973]
+  - index: 7
+    pos: [-38.1, 197.973]
+  - index: 8
+    pos: [38.1, 197.973]
+  - index: 9
+    pos: [114.3, 197.973]
+  - index: 10
+    pos: [190.5, 197.973]
+  - index: 11
+    pos: [-228.6, 131.982]
+  - index: 12
+    pos: [-152.4, 131.982]
+  - index: 13
+    pos: [-76.2, 131.982]
+  - index: 14
+    pos: [0, 131.982]
+  - index: 15
+    pos: [76.2, 131.982]
+  - index: 16
+    pos: [152.4, 131.982]
+  - index: 17
+    pos: [228.6, 131.982]
+  - index: 18
+    pos: [-266.7, 65.991]
+  - index: 19
+    pos: [-190.5, 65.991]
+  - index: 20
+    pos: [-114.3, 65.991]
+  - index: 21
+    pos: [114.3, 65.991]
+  - index: 22
+    pos: [190.5, 65.991]
+  - index: 23
+    pos: [266.7, 65.991]
+  - index: 24
+    pos: [-304.8, 0]
+  - index: 25
+    pos: [-228.6, 0]
+  - index: 26
+    pos: [-152.4, 0]
+  - index: 27
+    pos: [152.4, 0]
+  - index: 28
+    pos: [228.6, 0]
+  - index: 29
+    pos: [304.8, 0]
+  - index: 30
+    pos: [-266.7, -65.991]
+  - index: 31
+    pos: [-190.5, -65.991]
+  - index: 32
+    pos: [-114.3, -65.991]
+  - index: 33
+    pos: [114.3, -65.991]
+  - index: 34
+    pos: [190.5, -65.991]
+  - index: 35
+    pos: [266.7, -65.991]
+  - index: 36
+    pos: [-228.6, -131.982]
+  - index: 37
+    pos: [-152.4, -131.982]
+  - index: 38
+    pos: [-76.2, -131.982]
+  - index: 39
+    pos: [0, -131.982]
+  - index: 40
+    pos: [76.2, -131.982]
+  - index: 41
+    pos: [152.4, -131.982]
+  - index: 42
+    pos: [228.6, -131.982]
+  - index: 43
+    pos: [-190.5, -197.973]
+  - index: 44
+    pos: [-114.3, -197.973]
+  - index: 45
+    pos: [-38.1, -197.973]
+  - index: 46
+    pos: [38.1, -197.973]
+  - index: 47
+    pos: [114.3, -197.973]
+  - index: 48
+    pos: [190.5, -197.973]
+  - index: 49
+    pos: [-152.4, -263.965]
+  - index: 50
+    pos: [-76.2, -263.965]
+  - index: 51
+    pos: [0, -263.965]
+  - index: 52
+    pos: [76.2, -263.965]
+  - index: 53
+    pos: [152.4, -263.965]

database.py

@@ -1,140 +0,0 @@
-"""This module contains functionality for interacting with a PostgreSQL database. It will automatically handle error
-conditions (i.e. missing columns) without terminating the entire program. Use the :py:class:`DBConnector` class to
-handle database interactions, either as a standalone object or in a context manager."""
-from __future__ import annotations
-
-import os
-import psycopg2
-from psycopg2 import DatabaseError, OperationalError
-from psycopg2.errors import UndefinedColumn
-
-DB_ADDRESS = os.getenv('DB_ADDRESS', 'localhost')
-DB_PORT = os.getenv('DB_PORT', 5432)
-DB_USER = os.getenv('DB_USER', 'postgres')
-DB_PASSWORD = os.getenv('DB_PASSWORD', '')
-DB_NAME = os.getenv('DB_NAME', 'postgres')
-DB_TABLE = os.getenv('DB_TABLE', 'cables')
-
-
-class DBConnector:
-    """Context managed database class. Use with statements to automatically open and close the database connection, like
-    so:
-
-    .. code-block:: python
-       with DBConnector() as db:
-           db.read()
-    """
-
-    def _db_start(self):
-        """Setup the database connection and cursor."""
-        try:
-            self.conn = psycopg2.connect(
-                f"host={DB_ADDRESS} port={DB_PORT} dbname={DB_NAME} user={DB_USER} password={DB_PASSWORD}")
-            self.cur = self.conn.cursor()
-        except OperationalError as e:
-            raise e
-
-    def _db_stop(self):
-        """Close the cursor and connection."""
-        self.cur.close()
-        self.conn.close()
-
-    def __init__(self):
-        self._db_start()
-
-    def __del__(self):
-        self._db_stop()
-
-    def __enter__(self):
-        self._db_start()
-
-    def __exit__(self):
-        self._db_stop()
-
-    def _get_cols(self) -> set[str]:
-        """Get the list of columns in the database.
-
-        :return: A list of column names."""
-        query = f"select COLUMN_NAME from information_schema.columns where table_name={DB_TABLE}"
-        rows = {x["COLUMN_NAME"] for x in self._query(query)}
-        return rows
-
-    def _column_parity(self, columns: list[str] | set[str]) -> set[str]:
-        """If the listed columns are not in the database, add them.
-
-        :param columns: The columns we expect are in the database.
-        :return: The list of columns in the database after querying."""
-        cols = set(columns)
-        existing = self._get_cols()
-        needs = cols.difference(existing.intersection(cols))
-        if len(needs) > 0:
-            query = f"ALTER TABLE {DB_TABLE} {', '.join([f'ADD COLUMN {c}' for c in needs])}"
-            self._query(query)
-            existing = self._get_cols()
-        return existing
-
-    def _query(self, sql) -> list[dict]:
-        """Basic function for running queries.
-
-        :param sql: SQL query as plaintext.
-        :return: Results of the query, or an empty list if none."""
-        result = []
-        try:
-            self.cur.execute(sql)
-            result = self._read_dict()
-        except DatabaseError as e:
-            print(f"ERROR {e.pgcode}: {e.pgerror}\n"
-                  f"Caused by query: {sql}")
-        finally:
-            return result
-
-    def _read_dict(self) -> list[dict]:
-        """Read the cursor as a list of dictionaries. psycopg2 defaults to using a list of tuples, so we want to convert
-        each row into a dictionary before we return it."""
-        cols = [i.name for i in self.cur.description]
-        results = []
-        for row in self.cur:
-            row_dict = {}
-            for i in range(0, len(row)):
-                if row[i]:
-                    row_dict = {**row_dict, cols[i]: row[i]}
-            results.append(row_dict)
-        return results
-
-    def read(self, **kwargs) -> list[dict]:
-        """Read rows from a database that match the specified filters.
-
-        :param kwargs: Column constraints; i.e. what value to filter by in what column.
-        :returns: A list of dictionaries of all matching rows, or an empty list if no match."""
-        args = []
-        for kw in kwargs.keys():
-            args.append(f"{kw} ILIKE {kwargs['kw']}")
-        query = f"SELECT * FROM {DB_TABLE}"
-        if len(args) > 0:
-            query += f" WHERE {' AND '.join(args)}"
-        return self._query(query)
-
-    def write(self, **kwargs) -> dict:
-        """Write a row to the database.
-
-        :param kwargs: Values to write for each database; specify each column separately!
-        :returns: The row you just added."""
-        self._column_parity(set(kwargs.keys()))
-        values = []
-        for val in kwargs.keys():
-            values.append(kwargs[val])
-        query = f"INSERT INTO {DB_TABLE} ({', '.join(kwargs.keys())}) VALUES ({', '.join(values)})"
-        self._query(query)
-        return kwargs
-
-    def write_all(self, items: list[dict]) -> list[dict]:
-        """Write multiple rows to the database.
-
-        :param items: Rows to write, as a list of dictionaries.
-        :returns: The rows that were added successfully."""
-        successes = []
-        for i in items:
-            res0 = self.write(**i)
-            if res0:
-                successes.append(res0)
-        return successes

get_specs.py

@@ -5,7 +5,7 @@ import sys
 import read_datasheet
 from alive_progress import alive_bar
 import requests
-#import time
+import time
 import json
 import subprocess
 from util import fprint
@@ -26,30 +26,79 @@ def check_internet(url='https://belden.com', timeout=5):
     
 
 
-def query_search(partnum):
-    """token_url = "https://www.belden.com/coveo/rest/token?t=" + str(int(time.time()))
+def query_search(partnum, source):
+    if source == "Belden":
+        token_url = "https://www.belden.com/coveo/rest/token?t=" + str(int(time.time()))
         with requests.get(token_url) as r:
             out = json.loads(r.content)
         token = out["token"]
         search_url = "https://www.belden.com/coveo/rest/search"
-    search_data ='{ "q": "' + str(partnum) + '", "sortCriteria": "relevancy", "numberOfResults": "250", "sortCriteria": "@catalogitemwebdisplaypriority ascending", "searchHub": "products-only-search", "pipeline": "Site Search", "maximumAge": "900000", "tab": "products-search", "locale": "en" }'
+
+        # Ridiculous search parameters extracted from website. Do not touch
+        search_data = r"""{ "q": "{QUERY}", "sortCriteria": "relevancy", "numberOfResults": "250", "sortCriteria": "@catalogitemwebdisplaypriority ascending", "searchHub": "products-only-search", "pipeline": "Site Search", "maximumAge": "900000", "tab": "products-search", "locale": "en", "aq": "(NOT @z95xtemplate==(ADB6CA4F03EF4F47B9AC9CE2BA53FF97,FE5DD82648C6436DB87A7C4210C7413B)) ((@syssource==\"website_001002_catalog_index-rg-nc-prod-sitecore-prod\" @catalogitemprimarycategorypublished==true)) ((@catalogitemregionavailable=Global) (@z95xlanguage==en))", "cq": "((@z95xlanguage==en) (@z95xlatestversion==1) (@source==\"Coveo_web_index - rg-nc-prod-sitecore-prod\")) OR (@source==(\"website_001002_catalog_index-rg-nc-prod-sitecore-prod\",\"website_001002_Category_index-rg-nc-prod-sitecore-prod\"))", "firstResult": "0" }, "categoryFacets": "[{\"field\":\"@catalogitemcategories\",\"path\":[],\"injectionDepth\":1000,\"maximumNumberOfValues\":6,\"delimitingCharacter\":\"|\"}]", "facetOptions": "{}", "groupBy": "    [{\"field\":\"@contenttype\",\"maximumNumberOfValues\":6,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[\"Products\"],\"queryOverride\":\"{QUERY}\",\"advancedQueryOverride\":\"(NOT @z95xtemplate==(ADB6CA4F03EF4F47B9AC9CE2BA53FF97,FE5DD82648C6436DB87A7C4210C7413B)) ((((((((@z95xpath=3324AF2D58F64C0FB725521052F679D2 @z95xid<>3324AF2D58F64C0FB725521052F679D2) ((@z95xpath=C292F3A37B3A4E6BAB345DF87ADDE516 @z95xid<>C292F3A37B3A4E6BAB345DF87ADDE516) @z95xtemplate==E4EFEB787BDC4B1A908EFC64D56CB2A4)) OR ((@z95xpath=723501A864754FEEB8AE377E4C710271 @z95xid<>723501A864754FEEB8AE377E4C710271) ((@z95xpath=600114EAB0E5407A84AAA9F0985B6575 @z95xid<>600114EAB0E5407A84AAA9F0985B6575) @z95xtemplate==2BE4FD6B3B2C49EBBD9E1F6C92238B05))) OR (@syssource==\\"website_001002_catalog_index-rg-nc-prod-sitecore-prod\\" @catalogitemprimarycategorypublished==true)) OR ((@z95xpath=3324AF2D58F64C0FB725521052F679D2 @z95xid<>3324AF2D58F64C0FB725521052F679D2) @z95xpath<>C292F3A37B3A4E6BAB345DF87ADDE516)) OR @syssource==\\"website_001002_Category_index-rg-nc-prod-sitecore-prod\\") NOT @z95xtemplate==(ADB6CA4F03EF4F47B9AC9CE2BA53FF97,FE5DD82648C6436DB87A7C4210C7413B))) ((@catalogitemregionavailable=Global) (@z95xlanguage==en) OR (@contenttype=(Blogs,Resources,Other)) (NOT @ez120xcludefromcoveo==1))\",\"constantQueryOverride\":\"((@z95xlanguage==en) (@z95xlatestversion==1) (@source==\\"Coveo_web_index - rg-nc-prod-sitecore-prod\\")) OR (@source==(\\"website_001002_catalog_index-rg-nc-prod-sitecore-prod\\",\\"website_001002_Category_index-rg-nc-prod-sitecore-prod\\"))\"},{\"field\":\"@catalogitembrand\",\"maximumNumberOfValues\":6,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]},{\"field\":\"@catalogitemenvironment\",\"maximumNumberOfValues\":6,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]},{\"field\":\"@catalogitemregionalavailability\",\"maximumNumberOfValues\":6,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]},{\"field\":\"@prez45xtez120xt\",\"maximumNumberOfValues\":5,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]},{\"field\":\"@tags\",\"maximumNumberOfValues\":4,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]},{\"field\":\"@facetassettype\",\"maximumNumberOfValues\":3,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]},{\"field\":\"@facetbrand\",\"maximumNumberOfValues\":3,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]},{\"field\":\"@facetmarket\",\"maximumNumberOfValues\":6,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]},{\"field\":\"@facetsolution\",\"maximumNumberOfValues\":6,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]},{\"field\":\"@facetsearchcontentpagetype\",\"maximumNumberOfValues\":6,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]}]" }"""
+        search_data = search_data.replace(r"{QUERY}", partnum)
         #"aq": "", "cq": "((@z95xlanguage==en) (@z95xlatestversion==1) (@source==\\"Coveo_web_index - rg-nc-prod-sitecore-prod\\")) OR (@source==(\\"website_001002_catalog_index-rg-nc-prod-sitecore-prod\\",\\"website_001002_Category_index-rg-nc-prod-sitecore-prod\\"))", "firstResult": "0", "categoryFacets": "[{\\"field\\":\\"@catalogitemcategories\\",\\"path\\":[],\\"injectionDepth\\":1000,\\"maximumNumberOfValues\\":6,\\"delimitingCharacter\\":\\"|\\"}]", "facetOptions": "{}", "groupBy": "" }'
         #fprint(search_data)
-    fprint(json.loads(search_data))
+        #fprint(json.loads(search_data))
         #search_data = '{ "q": "' + str(partnum) + '" }'
-    fprint(search_data)
+        #fprint(search_data)
         headers = headers = {
             'Authorization': f'Bearer {token}',
             'Content-Type': 'application/json'
         }
+        try:
             with requests.post(search_url, headers=headers, data=search_data) as r:
-        fprint(r.text)"""
+                a = r.text
+                a = json.loads(a)
+                idx = -1
+                name = ""
+                for partid in range(len(a["results"])):
+                    name = a["results"][partid]["title"]
+                    if name != partnum:
+                        if name.find(partnum) >= 0:
+                            idx = partid
+                            break
+                        elif partnum.find(name) >= 0:
+                            idx = partid
+                            break
                         
-    # TODO: Reimplement in python
-    # Bash script uses some crazy json formatting that I could not figure out
-    # Despite the fact that I wrote it
-    # So I'll just leave it, becuase it works.
+                    else:
+                        idx = partid
+                        break
                         
+                if idx < 0:
+                    fprint("Could not find part in API: " + partnum)
+                    return False
+                fprint("Search result found: result " + str(idx) + ", for ID " + name)
+                #urlname = a["results"][0]["raw"]["catalogitemurlname"]
+                img = a["results"][idx]["raw"]["catalogitemimageurl"]
+                img = img[0:img.index("?")]
+                uri = a["results"][idx]["raw"]["clickableuri"]
+                dsid = a["results"][idx]["raw"]["catalogitemdatasheetid"]
+                brand = a["results"][idx]["raw"]["catalogitembrand"]
+                desc = a["results"][idx]["raw"]["catalogitemlongdesc"]
+                shortdesc = a["results"][idx]["raw"]["catalogitemshortdesc"]
+                a = json.dumps(a["results"][idx], indent=2)
+                #print(a, urlname, img, uri, dsurl)
+
+                out = dict()
+                out["url"] = "https://www.belden.com/products/" + uri
+                out["datasheet"] = "https://catalog.belden.com/techdata/EN/" + dsid + "_techdata.pdf"
+                out["brand"] = brand
+                out["name"] = shortdesc
+                out["description"] = desc
+                out["image"] = "https://www.belden.com" + img
+                out["partnum"] = name
+                #print(out)
+                return out
+        except:
+            print("falied to search with API. Falling back to datasheet lookup.")
+            return False
+    
+
+    # Original bash script
+    # superceded by above
+    if source == "Belden_shell":
         command = ["./query-search.sh", partnum]
         result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
         if result.returncode != 0: # error
@@ -58,6 +107,42 @@ def query_search(partnum):
         else:
             data_out = json.loads(result.stdout)
             return data_out
+    elif source == "Alphawire":
+        alphaurl = "https://www.alphawire.com//sxa/search/results/?l=en&s={4A774076-6068-460C-9CC6-A2D8E85E407F}&itemid={BF82F58C-EFD9-4D8B-AE3E-097DD12CF7DA}&sig=&autoFireSearch=true&productpartnumber=*" + partnum + "*&v={B22CD56D-AB95-4048-8AA1-5BBDF2F2D17F}&p=10&e=0&o=ProductPartNumber%2CAscending"
+        r = requests.get(url=alphaurl)
+        data = r.json()
+        output = dict()
+        #print(data)
+        try:
+            if data["Count"] > 0:
+                #print(data["Results"][0]["Url"])
+                for result in data["Results"]:
+                    if result["Url"].split("/")[-1] == partnum:
+                        #print(partnum)
+                        #print(result["Html"])
+                        try:
+                            imgidx = result["Html"].index("<img src=") + 10
+                            imgidx2 = result["Html"].index("?", imgidx)
+                            output["image"] = result["Html"][imgidx:imgidx2]
+                            if output["image"].index("http") != 0:
+                                output["image"] = ""
+                                print("No cable image found.")
+                        except:
+                            print("No cable image found.")
+
+                        dsidx = result["Html"].index("<a href=\"/disteAPI/") + 9
+                        dsidx2 = result["Html"].index(partnum, dsidx) + len(partnum)
+                        output["datasheet"] = "https://www.alphawire.com" + result["Html"][dsidx:dsidx2]
+                        output["partnum"] = partnum
+                        #"test".index()
+                        #print(output)
+                        return output
+
+
+        except:
+            return False
+        return False
+
 
 def touch(path):
     with open(path, 'a'):
@@ -65,7 +150,7 @@ def touch(path):
 
 
 
-def get_multi(partnums):
+def get_multi(partnums, delay=0.25):
     with alive_bar(len(partnums) * 2, dual_line=True, calibrate=30, bar="classic2", spinner="classic") as bar:
 
         def _try_download_datasheet(partnum, output_dir): # Guess datasheet URL
@@ -126,7 +211,7 @@ def get_multi(partnums):
                 sys.exit()
 
 
-        def _download_image(url, output_dir): # Download datasheet with known URL
+        def _download_image(url, output_dir): # Download image with known URL
             global bartext
 
             #fprint(url)
@@ -151,25 +236,32 @@ def get_multi(partnums):
                 os.remove(partnum + "/datasheet.pdf")
                 sys.exit()
 
-        def __use_cached_datasheet(partnum, path, output_dir):
+        def __use_cached_datasheet(partnum, path, output_dir, dstype):
             fprint("Using cached datasheet for " + partnum)
             bar.text = "Using cached datasheet for " + partnum
             bar(skipped=True)
+            if not os.path.exists(output_dir + "/parsed"):
+                
                 fprint("Parsing Datasheet contents of " + partnum)
                 bar.text = "Parsing Datasheet contents of " + partnum + ".pdf..."
-            read_datasheet.parse(path, output_dir)
-            bar(skipped=False)
             
-        def __downloaded_datasheet(partnum, path, output_dir):
+                read_datasheet.parse(path, output_dir, partnum, dstype)
+                bar(skipped=False) 
+            else:
+                fprint("Datasheet already parsed for " + partnum)
+                bar.text = "Datasheet already parsed for " + partnum + ".pdf"
+                bar(skipped=True)
+
+        def __downloaded_datasheet(partnum, path, output_dir, dstype):
             fprint("Downloaded " + path)
             bar.text = "Downloaded " + path
             bar(skipped=False)
             fprint("Parsing Datasheet contents of " + partnum)
             bar.text = "Parsing Datasheet contents of " + partnum + ".pdf..."
-            read_datasheet.parse(path, output_dir)
+            read_datasheet.parse(path, output_dir, partnum, dstype)
             bar(skipped=False)
 
-        for partnum in partnums:
+        def run_search(partnum):
             output_dir = "cables/" + partnum
             path = output_dir + "/datasheet.pdf"
             bartext = "Downloading files for part " + partnum
@@ -177,10 +269,16 @@ def get_multi(partnums):
             #
             if (not os.path.exists(output_dir + "/found_part_hires")) or not (os.path.exists(path) and os.path.getsize(path) > 1):
                 # Use query
-                search_result = query_search(partnum.replace(" ", ""))
+                search_result = query_search(partnum, dstype)
                 # Try to use belden.com search
                 if search_result is not False:
                     # Download high resolution part image if available and needed
+                    partnum = search_result["partnum"]
+                    output_dir = "cables/" + partnum
+                    path = output_dir + "/datasheet.pdf"
+                    bartext = "Downloading files for part " + partnum
+                    bar.text = bartext
+
                     if not os.path.exists(output_dir + "/found_part_hires"):
                         if _download_image(search_result["image"], output_dir):
                             fprint("Downloaded hi-res part image for " + partnum)
@@ -190,30 +288,61 @@ def get_multi(partnums):
 
                     # Download datasheet from provided URL if needed
                     if os.path.exists(path) and os.path.getsize(path) > 1:
-                        __use_cached_datasheet(partnum, path, output_dir)
+                        __use_cached_datasheet(partnum, path, output_dir, dstype)
 
                     elif _download_datasheet(search_result["datasheet"], output_dir) is not False:
-                        __downloaded_datasheet(partnum, path, output_dir)
+                        __downloaded_datasheet(partnum, path, output_dir, dstype)
                 
                 elif os.path.exists(path) and os.path.getsize(path) > 1:
-                    __use_cached_datasheet(partnum, path, output_dir)
+                    __use_cached_datasheet(partnum, path, output_dir, dstype)
                 
                 # If search fails, and we don't already have the datasheet, guess datasheet URL and skip the hires image download
                 elif _try_download_datasheet(partnum, output_dir) is not False:
-                    __downloaded_datasheet(partnum, path, output_dir)
+                    __downloaded_datasheet(partnum, path, output_dir, dstype)
 
                 # Failed to download with search or guess :(
                 else: 
+                    return False
+                return True
+
+            # We already have a hi-res image and the datasheet - perfect!
+            else:
+                fprint("Using cached hi-res part image for " + partnum)
+                __use_cached_datasheet(partnum, path, output_dir, dstype)
+                return True
+    
+        for fullpartnum in partnums:
+            if fullpartnum[0:2] == "BL": # catalog.belden.com entry
+                partnum = fullpartnum[2:]
+                dstype = "Belden"
+            elif fullpartnum[0:2] == "AW":
+                partnum = fullpartnum[2:]
+                dstype = "Alphawire"
+            else:
+                dstype = "Belden" # guess
+                partnum = fullpartnum
+            if not run_search(partnum):
+                success = False
+                if len(partnum.split(" ")) > 1:
+                    for name in partnum.split(" "):
+                        fprint("Retrying with alternate name: " + name)
+                        if(run_search(name)):
+                            success = True
+                            break
+                        time.sleep(delay)
+                    if not success:
+                        namestripped = partnum.strip(" ")
+                        fprint("Retrying with alternate name: " + namestripped)
+                        if(run_search(namestripped)):
+                            success = True
+                            time.sleep(delay)
+                if not success:
                     fprint("Failed to download datasheet for part " + partnum)
                     bar.text = "Failed to download datasheet for part " + partnum
                     failed.append(partnum)
                     bar(skipped=True)
                     bar(skipped=True)
-
-            # We already have a hi-res image and the datasheet - perfect!
-            else:
-                fprint("Using cached hi-res part image for " + partnum)
-                __use_cached_datasheet(partnum, path, output_dir)
+            time.sleep(delay)
             
     if len(failed) > 0:
         fprint("Failed to download:")
@@ -227,21 +356,73 @@ def get_multi(partnums):
 
 
 if __name__ == "__main__":
-    partnums = ["10GXS12", "RST 5L-RKT 5L-949", 
-"10GXS13",
-"10GXW12",
-"10GXW13",
-"2412",
-"2413",
-"OSP6AU",
-"FI4D024P9",
-"FISD012R9",
-"FDSD012A9",
-"FSSL024NG",
-"FISX006W0",
-"FISX00103",
-"C6D1100007"
+    # partnums = ["BLFISX012W0", "BL7958A", "BL10GXS12", "BLRST 5L-RKT 5L-949", 
+    # "BL10GXS13",
+    # "BL10GXW12",
+    # "BL10GXW13",
+    # "BL2412",
+    # "BL2413",
+    # "BLOSP6AU",
+    # "BLFI4D024P9",
+    # "BLFISD012R9",
+    # "BLFDSD012A9",
+    # "BLFSSL024NG",
+    # "BLFISX006W0",
+    # "BLFISX00103",
+    # "BLC6D1100007"
+    # ]
+    partnums = [
+    # Actual cables in Jukebox
+    "AW86104CY",
+    "AW3050",
+    "AW6714",
+    "AW1172C",
+    "AW2211/4",
+
+    "BLTF-1LF-006-RS5N",
+    "BLTF-SD9-006-RI5N",
+    "BLTT-SLG-024-HTNN",
+    "BLFISX012W0",
+    "BLFI4X012W0",
+    "BLSPE101 006Q",
+    "BLSPE102 006Q",
+    "BL7922A 010Q",
+    "BL7958A 008Q",
+    "BLIOP6U 010Q",
+    "BL10GXW13 D15Q",
+    "BL10GXW53 D15Q",
+    "BL29501F 010Q",
+    "BL29512 010Q",
+    "BL3106A 010Q",
+    "BL9841 060Q",
+    "BL3105A 010Q",
+    "BL3092A 010Q",
+    "BL8760 060Q",
+    "BL6300UE 008Q",
+    "BL6300FE 009Q",
+    "BLRA500P 006Q",
+
+
+    # Some ones I picked, including some invalid ones
+    "BL10GXS12", 
+    "BLRST 5L-RKT 5L-949", 
+    "BL10GXS13",
+    "BL10GXW12",
+    "BL10GXW13",
+    "BL2412",
+    "BL2413",
+    "BLOSP6AU",
+    "BLFI4D024P9",
+    "BLFISD012R9",
+    "BLFDSD012A9",
+    "BLFSSL024NG",
+    "BLFISX006W0",
+    "BLFISX00103",
+    "BLC6D1100007"
+
     ]
-    get_multi(partnums)
+    #query_search("86104CY", "Alphawire")
+    get_multi(partnums, 0.25)
+    #query_search("10GXS13", "Belden")
 
 

install-deps.sh

@@ -1,4 +1,5 @@
 #!/bin/sh
+# change this to #!/bin/bash for windows
 
 if ! [ -d "venv" ]; then
     ./venv-setup.sh

inv_kin_testing.ipynb

@@ -0,0 +1,463 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Inverse Kinematics Simulation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from scipy.optimize import fsolve\n",
+    "import matplotlib.pyplot as plt\n",
+    "import math\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Polar coordinate functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cartesian_to_polar(x, y):\n",
+    "    r = np.sqrt(x**2 + y**2)\n",
+    "    theta = np.arctan2(y, x)\n",
+    "    return r, theta\n",
+    "\n",
+    "def polar_to_cartesian(r, theta):\n",
+    "    x = r * np.cos(theta)\n",
+    "    y = r * np.sin(theta)\n",
+    "    return x, y"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Calculate end-joint values from xyz position"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "flip\n",
+      "[62.18186071534606, -126.63734509021032, 142.6959710408549, -106.0586259506446]\n"
+     ]
+    }
+   ],
+   "source": [
+    "def normalize_degree(theta):\n",
+    "    # Normalizes degree theta from -1.5pi to 1.5pi\n",
+    "    multiplier = 1.5\n",
+    "    normalized_theta = theta % (math.pi * multiplier)\n",
+    "    \n",
+    "    # Maintain the negative sign if the original angle is negative\n",
+    "    if theta < 0:\n",
+    "        normalized_theta -= math.pi * multiplier\n",
+    "\n",
+    "    # Return angle\n",
+    "    return normalized_theta\n",
+    "\n",
+    "def get_joints_from_xyz_rel(x, y, z, rx=0, ry=0, rz=0, tool_offset=(0.145, 0, 0.14), initial_guess = (math.pi/2, math.pi/2, 0)):\n",
+    "    # Get limbs and offsets\n",
+    "    offset_x, offset_y, offset_z = tool_offset\n",
+    "    l_bs, l1, l2, l3 = (0.14, .422864, .359041, .15)\n",
+    "\n",
+    "    # Calculate base angle and r relative to shoulder joint\n",
+    "    def calculate_theta(x, y, a):\n",
+    "        # Calculate if we need the + or - in our equations\n",
+    "        if (x>-a and y>=0) or (x>a and y<0):\n",
+    "            print('no flip')\n",
+    "            flip = 1\n",
+    "        elif (x<-a and y>=0) or (x<a and y<0):\n",
+    "            print('flip')\n",
+    "            flip = -1\n",
+    "        else: \n",
+    "            print('critical')\n",
+    "            # Critical section (x=a, or x=-a). Infinite slope\n",
+    "            # Return 0 or 180 depending on sign\n",
+    "            return math.atan2(y, 0)\n",
+    "        \n",
+    "        # Calculate tangent line y = mx + b\n",
+    "        m = (x*y - math.sqrt(x*x*y*y-(x*x-a*a)*(y*y-a*a)))/(x*x-a*a)\n",
+    "        b = flip * a * math.sqrt(1+m*m)\n",
+    "\n",
+    "        # Calculate equivalent tangent point on circle\n",
+    "        cx = (-flip*m*b)/(1+m*m)\n",
+    "        cy = m*cx + flip*b\n",
+    "\n",
+    "        # Calculate base angle, make angle negative if flip=1\n",
+    "        theta = math.atan2(cy, cx) + (-math.pi if flip==1 else 0)\n",
+    "\n",
+    "        return theta\n",
+    "    \n",
+    "    base_theta = calculate_theta(x, y, l_bs)\n",
+    "    cx, cy = l_bs*math.cos(base_theta), l_bs*math.sin(l_bs)\n",
+    "    r = math.sqrt((x-cx)**2 + (y-cy)**2) - 0.1\n",
+    "\n",
+    "\n",
+    "    # Formulas to find out joint positions for (r, z)\n",
+    "    def inv_kin_r_z(p):\n",
+    "        a, b, c = p            \n",
+    "\n",
+    "        return (l1*math.cos(a) + l2*math.cos(a-b) + l3*math.cos(a-b-c) - r, # r\n",
+    "                l1*math.sin(a) + l2*math.sin(a-b) - l3*math.sin(a-b-c) - (z+offset_z),  # z\n",
+    "                a-b-c) # wrist angle\n",
+    "\n",
+    "\n",
+    "    # Normalize angles\n",
+    "    base, shoulder, elbow, wrist1 = [normalize_degree(deg) for deg in [base_theta, *fsolve(inv_kin_r_z, initial_guess)]]\n",
+    "\n",
+    "    # Return result\n",
+    "    return base, shoulder, elbow, wrist1, ry, rz\n",
+    "\n",
+    "def get_joints_from_xyz_abs(x, y, z):\n",
+    "    joints = get_joints_from_xyz_rel(x, y, z)\n",
+    "\n",
+    "    # Joint offsets\n",
+    "    # Base, Shoulder, Elbow, Wrist\n",
+    "    inverse = [1, -1, 1, 1, 1, 1]\n",
+    "    offsets = [-math.pi/2, 0, 0, -math.pi/2, -math.pi/2, 0]\n",
+    "\n",
+    "    # Return adjusted joint positions\n",
+    "    return [o+j*i for j, o, i in zip(joints, offsets, inverse)]\n",
+    "\n",
+    "# print([math.degrees(deg) for deg in get_joints_from_xyz_rel(0.3, 0.3, 0.3)])\n",
+    "print([math.degrees(deg) for deg in get_joints_from_xyz_abs(0, -0.3, 0.1)])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "no flip\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "-126.86989764584402"
+      ]
+     },
+     "execution_count": 64,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def calculate_theta(x, y, a):\n",
+    "        # Calculate if we need the + or - in our equations\n",
+    "        if (x>a and y>=0) or (x>-a and y<0):\n",
+    "            print('no flip')\n",
+    "            flip = 1\n",
+    "        elif (x<a and y>=0) or (x<-a and y<0):\n",
+    "            print('flip')\n",
+    "            flip = -1\n",
+    "        else: \n",
+    "            print('critical')\n",
+    "            # Critical section (x=a, or x=-a). Infinite slope\n",
+    "            # Return 0 or 180 depending on sign\n",
+    "            return math.atan2(y, 0)\n",
+    "        \n",
+    "        # Calculate tangent line y = mx + b\n",
+    "        m = (x*y + math.sqrt(x*x*y*y-(x*x-a*a)*(y*y-a*a)))/(x*x-a*a)\n",
+    "        b = flip * a * math.sqrt(1+m*m)\n",
+    "\n",
+    "        # Calculate equivalent tangent point on circle\n",
+    "        cx = (-flip*m*b)/(1+m*m)\n",
+    "        cy = m*cx + flip*b\n",
+    "\n",
+    "        # Calculate base angle\n",
+    "        theta = math.atan2(cy, cx) + (-math.pi if flip==1 else 0)\n",
+    "\n",
+    "        return theta\n",
+    "\n",
+    "calculate_theta(5,-5,1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Simulate arm and joint angles"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "no flip\n",
+      "Target position (x,y,z): 0.3 0.3 0.3\n",
+      "Angles (base, shoulder, elbow, wrist): [-25.7322, 113.4225, 127.6133, -14.1908]\n",
+      "no flip\n",
+      "Robot Angles: [-115.7322, -113.4225, 127.6133, -104.1908]\n",
+      "elbow (x,y): -0.168 0.388\n",
+      "wrist (x,y): 0.18 0.3\n",
+      "tool  (x,y): 0.33 0.3\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def draw_arm(x, y, z):\n",
+    "\n",
+    "    # Get joint angles\n",
+    "    l1, l2, l3 = (.422864, .359041, .15)\n",
+    "    offset_x, offset_y, offset_z = (0.145, 0, 0.195)\n",
+    "    r, theta = cartesian_to_polar(x, y)\n",
+    "    base, shoulder, elbow, wrist = get_joints_from_xyz_rel(x, y, z)\n",
+    "\n",
+    "    # Print angles\n",
+    "    print('Target position (x,y,z):', x, y, z)\n",
+    "    print('Angles (base, shoulder, elbow, wrist):', [round(math.degrees(i), 4) for i in [base, shoulder, elbow, wrist]])\n",
+    "    print('Robot Angles:', [round(math.degrees(i), 4) for i in get_joints_from_xyz_abs(x, y, z)])\n",
+    "\n",
+    "    # Calculate each joint's endpoint position\n",
+    "    x1, y1 = polar_to_cartesian(l1, shoulder)\n",
+    "    x2, y2 = polar_to_cartesian(l2, shoulder-elbow)\n",
+    "    x2 += x1\n",
+    "    y2 += y1\n",
+    "    x3, y3 = polar_to_cartesian(l3, shoulder-elbow-wrist)\n",
+    "    x3 += x2\n",
+    "    y3 += y2 \n",
+    "    \n",
+    "    tx = x3\n",
+    "    ty = y3 - offset_z\n",
+    "\n",
+    "    # Print each joint's endpoint position\n",
+    "    print('elbow (x,y):', round(x1,3), round(y1,3))\n",
+    "    print('wrist (x,y):', round(x2,3), round(y2,3))\n",
+    "    print('tool  (x,y):', round(x3,3), round(y3,3))\n",
+    "\n",
+    "    # Draw limbs\n",
+    "    plt.plot([0, x1], [0, y1], color='cyan', linewidth=7)\n",
+    "    plt.plot([x1, x2], [y1, y2], color='orange', linewidth=7)\n",
+    "    plt.plot([x2, x2+l3], [y2, y2], color='red', linewidth=7)\n",
+    "    plt.plot()\n",
+    "\n",
+    "    # Draw toolpoint\n",
+    "    plt.plot([x3, tx], [y3, ty], color='black', linewidth=7)\n",
+    "\n",
+    "    # Display angles\n",
+    "    plt.text(0, 0.02, f'{round(math.degrees(shoulder), 2)}°')\n",
+    "    plt.text(x1, y1+0.02, f'{round(math.degrees(elbow), 2)}°')\n",
+    "    plt.text(x2, y2+0.02, f'{round(math.degrees(wrist), 2)}°')\n",
+    "\n",
+    "    # Display r arrow\n",
+    "    plt.annotate(f'', xy=(0, 0), xycoords='data', xytext=(x3, 0), textcoords='data', arrowprops={'arrowstyle': '<->'})\n",
+    "    plt.annotate(f'r={round(r,4)}', xy=(x2/2, 0.01), xycoords='data', xytext=(x2/2, 0), textcoords='offset points')\n",
+    "\n",
+    "    # Display z arrow\n",
+    "    plt.annotate(f'', xy=(x3, 0), xycoords='data', xytext=(tx, ty), textcoords='data', arrowprops={'arrowstyle': '<->'})\n",
+    "    plt.annotate(f'z={round(ty,4)}', xy=(x3+0.01, y2/2), xycoords='data', xytext=(x3/2, 0), textcoords='offset points')\n",
+    "   \n",
+    "    # Display plot\n",
+    "    ax = plt.subplot(111)\n",
+    "    ax.spines[['right', 'top']].set_visible(False)\n",
+    "    plt.axis('equal')\n",
+    "    plt.show()\n",
+    "\n",
+    "draw_arm(0.3, 0.3, 0.3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Target position (x,y,z): 0.3 0.3 0.3\n",
+      "Angles (base, shoulder, elbow, wrist): [33.9862, 85.2162, 73.3858, 11.8304]\n",
+      "Robot Angles: [33.9862, -85.2162, 73.3858, -78.1696]\n",
+      "elbow (x,y): 0.035 0.421\n",
+      "wrist (x,y): 0.387 0.495\n",
+      "tool  (x,y): 0.537 0.495\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Target position (x,y,z): -0.3 -0.3 0.7\n",
+      "Angles (base, shoulder, elbow, wrist): [-117.3239, 78.0693, 0.0255, 79.0945]\n",
+      "Robot Angles: [-117.3239, -78.0693, 0.0255, -10.9055]\n",
+      "elbow (x,y): 0.087 0.414\n",
+      "wrist (x,y): 0.162 0.765\n",
+      "tool  (x,y): 0.312 0.762\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\nadee\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\scipy\\optimize\\_minpack_py.py:178: RuntimeWarning: The iteration is not making good progress, as measured by the \n",
+      "  improvement from the last ten iterations.\n",
+      "  warnings.warn(msg, RuntimeWarning)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Target position (x,y,z): -0.3 0.4 0.2\n",
+      "Angles (base, shoulder, elbow, wrist): [111.1813, 100.8341, 104.0795, -3.2455]\n",
+      "Robot Angles: [111.1813, -100.8341, 104.0795, -93.2455]\n",
+      "elbow (x,y): -0.079 0.415\n",
+      "wrist (x,y): 0.279 0.395\n",
+      "tool  (x,y): 0.429 0.395\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "draw_arm(0.3, 0.3, 0.3)\n",
+    "draw_arm(-0.3, -0.3, 0.7)\n",
+    "draw_arm(-0.3, 0.4, 0.2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Interactive Arm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "30dd696bcdc14aec9a1d4c17fb4787d4",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(FloatSlider(value=0.3, description='x', max=1.0, step=0.01), FloatSlider(value=0.3, desc…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.draw_arm(x, y, z)>"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from ipywidgets import interact, FloatSlider\n",
+    "\n",
+    "# Interactive slider for z coordinate\n",
+    "interact(draw_arm,  x=FloatSlider(min=0, max=1, step=0.01, value=0.3),\n",
+    "                    y=FloatSlider(min=0, max=1, step=0.01, value=0.3),\n",
+    "                    z=FloatSlider(min=0, max=1, step=0.01, value=0.3))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

led_control.py

@@ -22,6 +22,13 @@ leds_size = None
 leds_normalized = None
 controllers = None
 data = None
+exactdata = None
+rings = None
+ringstatus = None
+mode = "Startup"
+firstrun = True
+changecount = 0
+animation_time = 0
 start = uptime()
 
 def ping(host):
@@ -48,30 +55,50 @@ def map():
     global leds_size
     global leds_normalized
     global controllers
+    global rings
+    global ringstatus
+    global animation_time
+    
 
     with open('config.yml', 'r') as fileread:
         #global config
         config = yaml.safe_load(fileread)
 
+    animation_time = config["animation_time"]
     leds = list()
     leds_size = list()
     controllers = list()
+    rings = list(range(len(config["position_map"])))
+    ringstatus = list(range(len(config["position_map"])))
+    #print(rings)
     #fprint(config["led"]["map"])
+    generate_map = False
+    map = list()
     for shape in config["led"]["map"]:
         if shape["type"] == "circle":
+            
+            if generate_map:
+                map.append((shape["pos"][1],shape["pos"][0]))
             #fprint(shape["pos"])
             anglediv = 360.0 / shape["size"]
             angle = 0
             radius = shape["diameter"] / 2
             lednum = shape["start"]
+            for item in config['position_map']:
+            # Check if the current item's position matches the target position
+                #print(item['pos'],(shape["pos"][1],shape["pos"][0]))
+                if tuple(item['pos']) == (shape["pos"][1],shape["pos"][0]):
+                    rings[item["index"]] = (shape["pos"][1],shape["pos"][0],lednum,lednum+shape["size"]) # rings[index] = x, y, startpos, endpos
+                    ringstatus[item["index"]] = [None, None]
+                    break
             if len(leds) < lednum + shape["size"]:
                 for x in range(lednum + shape["size"] - len(leds)):
                     leds.append(None)
                     leds_size.append(None)
             while angle < 359.999:
                 tmpangle = angle + shape["angle"]
-                x = math.cos(tmpangle * (math.pi / 180.0)) * radius + shape["pos"][0]
-                y = math.sin(tmpangle * (math.pi / 180.0)) * radius + shape["pos"][1]
+                x = math.cos(tmpangle * (math.pi / 180.0)) * radius + shape["pos"][1] # flip by 90 degress when we changed layout
+                y = math.sin(tmpangle * (math.pi / 180.0)) * radius + shape["pos"][0]
                 leds[lednum] = (x,y)
                 lednum = lednum + 1
                 angle = angle + anglediv
@@ -97,7 +124,23 @@ def map():
                 dist += distdiv
                 lednum = lednum + 1
 
+    if generate_map:
+        map = sorted(map, key=lambda x: (-x[1], x[0]))
+        print(map)
+        import matplotlib.pyplot as plt
+        plt.axis('equal')
+        x, y = zip(*map)
+        plt.scatter(x, y, s=12)
+        #plt.plot(x, y, marker='o')
+        #plt.scatter(*zip(*leds), s=3)
+        for i, (x_pos, y_pos) in enumerate(map):
+            plt.text(x_pos, y_pos, str(i), color="red", fontsize=12)
+        plt.savefig("map2.png", dpi=600, bbox_inches="tight")
+        data = {"map": [{"index": i, "pos": str(list(pos))} for i, pos in enumerate(map)]}
+        yaml_str = yaml.dump(data, default_flow_style=False)
+        print(yaml_str)
 
+    print(rings)
     flag = 0
     for x in leds:
         if x is None:
@@ -148,9 +191,10 @@ def init():
     global leds_size
     global controllers
     global data
+    global exactdata
     sender = sacn.sACNsender(fps=config["led"]["fps"], universeDiscovery=False)
     sender.start()  # start the sending thread
-    for x in range(len(controllers)):
+    """for x in range(len(controllers)):
         print("Waiting for the controller at", controllers[x][2], "to be online...", end="")
         count = 0
         while not ping(controllers[x][2]):
@@ -159,7 +203,7 @@ def init():
                 fprint(" ERROR: controller still offline after " + str(count) + " seconds, continuing...")
                 break
         if count < config["led"]["timeout"]:
-            fprint(" done")
+            fprint(" done")"""
     for x in range(len(controllers)):
         print("Activating controller", x, "at", controllers[x][2], "with", controllers[x][1]-controllers[x][0], "LEDs.")
         sender.activate_output(x+1)  # start sending out data
@@ -168,22 +212,26 @@ def init():
 
     # initialize global pixel data list
     data = list()
+    exactdata = list()
     for x in range(len(leds)):
         if leds_size[x] == 3:
+            exactdata.append(None)
             data.append((20,20,127))
         elif leds_size[x] == 4:
+            exactdata.append(None)
             data.append((50,50,255,0))
         else:
+            exactdata.append(None)
             data.append((0,0,0))
     sendall(data)
     #time.sleep(50000)    
     fprint("Running start-up test sequence...")
     for y in range(1):
         for x in range(len(leds)):
-            setpixel(5,5,5,x)
+            setpixel(0,60,144,x)
         sendall(data)
         #time.sleep(2)
-        #alloffsmooth()
+    alloffsmooth()
 
 def sendall(datain):
     # send all LED data to all controllers
@@ -260,6 +308,209 @@ def setpixelnow(r, g, b, num):
     setpixel(r,g,b,num)
     senduniverse(data, num)
 
+def setmode(stmode, r=0,g=0,b=0):
+    global mode
+    global firstrun
+    if stmode is not None:
+        if mode != stmode:
+            firstrun = True
+    
+        mode = stmode
+    
+
+def setring(r,g,b,idx):
+    
+    ring = rings[idx]
+    for pixel in range(ring[2],ring[3]):
+        setpixel(r,g,b,pixel)
+    #global data
+    #senduniverse(data, ring[2])
+
+def runmodes(ring = -1, speed = 1):
+    global mode
+    global firstrun
+    global changecount
+    fprint("Mode: " + str(mode))
+    if mode == "Startup":
+        # loading animation. cable check
+        if firstrun:
+            changecount = animation_time * 3
+            firstrun = False
+            for x in range(len(ringstatus)):
+                ringstatus[x] = [True, animation_time]
+            
+        if changecount > 0:
+            fprint(changecount)
+            changecount = fadeorder(0,len(leds), changecount, 0,50,100)
+        else:
+            setmode("Startup2")
+            
+                
+    elif mode == "Startup2":
+        if firstrun:
+            firstrun = False
+            
+        else:
+            for x in range(len(ringstatus)):
+                if ringstatus[x][0]:
+                    setring(0, 50, 100, x)
+                else:
+                    ringstatus[x][1] = fadeall(rings[x][2],rings[x][3], ringstatus[x][1], 100,0,0) # not ready
+
+    elif mode == "StartupCheck":
+        if firstrun:
+            firstrun = False
+            for x in range(len(ringstatus)):
+                ringstatus[x] = [False, animation_time]
+        else:
+            for x in range(len(ringstatus)):
+                if ringstatus[x][0]:
+                    ringstatus[x][1] = fadeall(rings[x][2],rings[x][3], ringstatus[x][1], 0,50,100) # ready  
+                else:
+                    setring(100, 0, 0, x)
+
+    elif mode == "GrabA":
+        if firstrun:
+            firstrun = False
+            changecount = animation_time # 100hz
+        if changecount > 0:
+            changecount = fadeall(rings[ring][2],rings[ring][3], changecount, 100,0,0)
+        else:
+            setring(100,0,0,ring)
+            setmode("GrabB")
+    elif mode == "GrabB":
+        if firstrun:
+            firstrun = False
+            changecount = animation_time # 100hz
+        if changecount > 0:
+            changecount = fadeorder(rings[ring][2],rings[ring][3], changecount, 0,100,0)
+        else:
+            setring(0,100,0,ring)
+            setmode("idle")
+    elif mode == "GrabC":
+        if firstrun:
+            firstrun = False
+            changecount = animation_time # 100hz
+        if changecount > 0:
+            changecount = fadeall(rings[ring][2],rings[ring][3], changecount, 0,50,100)
+        else:
+            setring(0,50,100,ring)
+            setmode("idle")
+    elif mode == "idle":
+        time.sleep(0)
+
+    sendall(data)
+            
+def fadeall(idxa,idxb,sizerem,r,g,b):
+    if sizerem < 1:
+        return 0
+    global exactdata
+    sum = 0
+    for x in range(idxa,idxb):
+        if exactdata[x] is None:
+            exactdata[x] = data[x]
+        old = exactdata[x]
+        dr = (r - old[0])/sizerem
+        sum += abs(dr)
+        dr += old[0]
+        dg = (g - old[1])/sizerem
+        sum += abs(dg)
+        dg += old[1]
+        db = (b - old[2])/sizerem 
+        db += old[2]
+        sum += abs(db)
+        exactdata[x] = (dr, dg, db)
+        #print(new)
+        setpixel(dr, dg, db, x)
+        if sizerem == 1:
+            exactdata[x] = None
+    if sum == 0 and sizerem > 2:
+        sizerem = 2
+    return sizerem - 1
+        
+def fadeorder(idxa,idxb,sizerem,r,g,b):
+    if sizerem < 1:
+        return 0
+    global exactdata
+    drs = 0
+    dgs = 0
+    dbs = 0
+    sum = 0
+    for x in range(idxa,idxb):
+        if exactdata[x] is None:
+            exactdata[x] = data[x]
+        old = exactdata[x]
+        dr = (r - old[0])
+        dg = (g - old[1])
+        db = (b - old[2])
+        drs += dr
+        dgs += dg
+        dbs += db
+    
+    drs /= sizerem
+    dgs /= sizerem
+    dbs /= sizerem
+    sum += abs(drs) + abs(dgs) + abs(dbs)
+    print(drs,dgs,dbs)
+    for x in range(idxa,idxb):
+        old = exactdata[x]
+        new = list(old)
+        if drs > 0:
+            if old[0] + drs > r:
+                new[0] = r
+                drs -= r - old[0]
+            else:
+                new[0] = old[0] + drs
+                drs = 0
+        if dgs > 0:
+            if old[1] + dgs > g:
+                new[1] = g
+                dgs -= g - old[1]
+            else:
+                new[1] = old[1] + dgs
+                dgs = 0
+        if dbs > 0:
+            if old[2] + dbs > b:
+                new[2] = b
+                dbs -= b - old[2]
+            else:
+                new[2] = old[2] + dbs
+                dbs = 0
+
+        if drs < 0:
+            if old[0] + drs < r:
+                new[0] = r
+                drs -= r - old[0]
+            else:
+                new[0] = old[0] + drs
+                drs = 0
+        if dgs < 0:
+            if old[1] + dgs < g:
+                new[1] = g
+                dgs -= g - old[1]
+            else:
+                new[1] = old[1] + dgs
+                dgs = 0
+        if dbs < 0:
+            if old[2] + dbs < b:
+                new[2] = b
+                dbs -= b - old[2]
+            else:
+                new[2] = old[2] + dbs
+                dbs = 0
+
+        if drs != 0 or dgs != 0 or dbs != 0:
+            exactdata[x] = new
+            setpixel(new[0],new[1],new[2],x)
+        
+        if sizerem == 1:
+            exactdata[x] = None
+
+    if sum == 0 and sizerem > 2:
+        sizerem = 2
+    return sizerem - 1
+
+
 def setpixel(r, g, b, num):
     global data
     global leds_size
@@ -290,7 +541,7 @@ def close():
     time.sleep(0.5)
     sender.stop()
 
-def mapimage(image, fps=60):
+def mapimage(image, fps=90):
     global start
     while uptime() - start < 1/fps:
         time.sleep(0.00001)
@@ -328,16 +579,105 @@ def mapimage(image, fps=60):
     global data
     fastsendall(data)
 
+def mainloop(stmode, ring = -1, fps = 100, preview = False):
+    global start
+    while uptime() - start < 1/fps:
+        time.sleep(0.00001)
+    fprint(1 / (uptime() - start))
+    start = uptime()
+    if mode is not None:
+        setmode(stmode)
+    runmodes(ring)
+    if preview:
+        drawdata()
+
+def drawdata():
+    #tmp = list()
+    #for x in len(leds):
+    #    led = leds[x]
+    #    tmp.append((led[0], led[1], data[x]))
+
+    x = [led[0] for led in leds]
+    y = [led[1] for led in leds]
+    colors = data
+    colors_normalized = [(x[0]/255, x[1]/255, x[2]/255) for x in colors]
+    # Plot the points
+    plt.scatter(x, y, c=colors_normalized)
+
+    # Optional: add grid, title, and labels
+    plt.grid(True)
+    plt.title('Colored Points')
+    plt.xlabel('X')
+    plt.ylabel('Y')
+    plt.show()
+    plt.savefig("map3.png", dpi=50, bbox_inches="tight")
+    plt.clf()
+
+def startup_animation(show):
+
+    
+    stmode = "Startup"
+    mainloop(stmode, preview=show)
+    while mode == "Startup":
+        mainloop(None, preview=show)
+    for x in range(54):
+        ringstatus[x][0] = False
+        mainloop(None, preview=show)
+
+    for x in range(animation_time):
+        mainloop(None, preview=show)
+    clear_animations()
+    stmode = "StartupCheck"
+    mainloop(stmode, preview=show)
+    clear_animations()
+
+def clear_animations():
+    for x in range(len(leds)):
+        exactdata[x] = None
+
+def do_animation(stmode, ring=-1):
+    mainloop(stmode, ring, preview=show)
+    wait_for_animation(ring)
+
+def start_animation(stmode, ring=-1):
+    mainloop(stmode, ring, preview=show)
+
+def wait_for_animation(ring=-1):
+    while mode != "idle":
+        mainloop(None, ring, preview=show)
 
 if __name__ == "__main__":
     init()
-    cap = cv2.VideoCapture('output.mp4')
+    import matplotlib.pyplot as plt
+    """cap = cv2.VideoCapture('badapple.mp4')
     while cap.isOpened():
         ret, frame = cap.read()
         if not ret:
             break
-        mapimage(frame)
+        mapimage(frame, fps=30)"""
+    show = True
+    ring = 1
+    startup_animation(show)
+    for x in range(54):
+        ringstatus[x][0] = True
+        mainloop(None, preview=show)
+    for x in range(animation_time):
+        mainloop(None, preview=show)
+    
+    do_animation("GrabA", 1)
+
+    do_animation("GrabA", 5)
+    start_animation("GrabC", 1)
+    
+    wait_for_animation(1)
+    do_animation("GrabC", 5)
     
-    time.sleep(1)
     close()
     #sys.exit(0)
+
+
+    # blue : default
+    # green : target
+    # yellow : crosshair
+    # red : missing 
+    # uninitialized : red/purple?

read_datasheet.py

@@ -2,6 +2,8 @@
 
 # Parse Belden catalog techdata datasheets 
 
+import pandas as pd
+pd.set_option('future.no_silent_downcasting', True)
 from PyPDF2 import PdfReader
 import camelot
 import numpy as np
@@ -9,8 +11,15 @@ from PIL import Image
 import io
 import json
 from util import fprint
+import uuid
+from util import run_cmd
+import os
 
-def parse(filename, output_dir):
+def touch(path):
+    with open(path, 'a'):
+        os.utime(path, None)
+
+def parse(filename, output_dir, partnum, dstype):
 
     # Extract table data
 
@@ -21,7 +30,9 @@ def parse(filename, output_dir):
     reader = PdfReader(filename)
     page = reader.pages[0]
     table_list = {}
+
     for table in tables:
+        table.df.infer_objects(copy=False)
         table.df.replace('', np.nan, inplace=True)
         table.df.dropna(inplace=True, how="all")
         table.df.dropna(inplace=True, axis="columns", how="all")
@@ -87,6 +98,7 @@ def parse(filename, output_dir):
 
     # Table parsing and reordring
     tables = dict()
+    torename = dict()
     previous_table = ""
     for table_name in table_list.keys():
         # determine shape: horizontal or vertical
@@ -118,7 +130,8 @@ def parse(filename, output_dir):
         for table_name_2 in table_list.keys(): 
             if table_name_2.find(table.iloc[-1, 0]) >= 0:
                 # Name taken from table directly above - this table does not have a name
-                table_list["Specs " + str(len(tables))] = table_list.pop(table_name_2, None) # rename table to arbitrary altername name
+                torename[table_name_2] = "Specs " + str(len(tables))
+                #table_list["Specs " + str(len(tables))] = table_list[table_name_2] # rename table to arbitrary altername name
                 break
 
         if vertical:
@@ -137,22 +150,23 @@ def parse(filename, output_dir):
 
 
         # multi-page table check
+        if dstype == "Belden":
             if table_name.isdigit() and len(tables) > 1:
-            fprint(table_name)
-            fprint(previous_table)
+                #fprint(table_name)
+                #fprint(previous_table)
                 
                 
                 
                 
                 main_key = previous_table
                 cont_key = table_name
-            fprint(tables)
+                #fprint(tables)
                 if vertical == False:
                     main_keys = list(tables[main_key].keys())
                     for i, (cont_key, cont_values) in enumerate(tables[cont_key].items()):
                         if i < len(main_keys):
-                        fprint(tables[main_key][main_keys[i]])
-                        tables[main_key][main_keys[i]] = (tables[main_key][main_keys[i]] + (cont_key,) + cont_values)
+                            #fprint(tables[main_key][main_keys[i]])
+                            tables[main_key][main_keys[i]] = (tuple(tables[main_key][main_keys[i]]) + (cont_key,) + cont_values)
     
                     del tables[table_name]
     
@@ -163,18 +177,92 @@ def parse(filename, output_dir):
 
         previous_table = table_name
     
+    # remove renamed tables
+    for table_name in torename.keys():
+        tables[torename[table_name]] = tables[table_name]
+        del tables[table_name]
+    # remove multi-line values that occasionally squeak through
+    def replace_newlines_in_dict(d):
+        for key, value in d.items():
+            if isinstance(value, str):
+                # Replace \n with " " if the value is a string
+                d[key] = value.replace('\n', ' ')
+            elif isinstance(value, dict):
+                # Recursively call the function if the value is another dictionary
+                replace_newlines_in_dict(value)
+        return d
     
-    fprint(tables)
-    with open(output_dir + "/tables.json", 'w') as json_file:
-        json.dump(tables, json_file)
+    tables = replace_newlines_in_dict(tables)
+
+    # summary
+
+    output_table = dict()
+    output_table["partnum"] = partnum
+    id = str(uuid.uuid4())
+    output_table["id"] = id
+    #output_table["position"] = id
+    #output_table["brand"] = brand
+    output_table["fullspecs"] = tables
+    output_table["searchspecs"] = {"partnum": partnum, **flatten(tables)}
+    
+    output_table["searchspecs"]["id"] = id
     
 
 
+    #print(output_table)
+
+    run_cmd("rm \"" + output_dir + "\"/*.json") # not reliable!
+    with open(output_dir + "/" + output_table["searchspecs"]["id"] + ".json", 'w') as json_file:
+        json.dump(output_table["searchspecs"], json_file)
+    touch(output_dir + "/parsed")
+    return output_table
 
 
-    return tables
+def flatten(tables):
+    def convert_to_number(s):
+        try:
+            # First, try converting to an integer.
+            return int(s)
+        except ValueError:
+            # If that fails, try converting to a float.
+            try:
+                return float(s)
+            except ValueError:
+                # If it fails again, return the original string.
+                return s
+    out = dict()
+    #print("{")
+    for table in tables.keys():
+        for key in tables[table].keys():
+            if len(key) < 64:
+                keyname = key
+            else:
+                keyname = key[0:64]
+
+            fullkeyname = (table + ": " + keyname).replace(".","")
+            if type(tables[table][key]) is not tuple:
+                out[fullkeyname] = convert_to_number(tables[table][key])
+                #print("\"" + keyname + "\":", "\"" + str(out[fullkeyname]) + "\",")
+            elif len(tables[table][key]) == 1:
+                out[fullkeyname] = convert_to_number(tables[table][key][0])
+                
+                #print("\"" + keyname + "\":", "\"" + str(out[fullkeyname]) + "\",")
+
+            # if the item has at least two commas in it, split it
+            if tables[table][key].count(',') > 0:
+                out[fullkeyname] = list(map(lambda x: x.strip(), tables[table][key].split(",")))
+                #print("\"" + keyname + "\":", "\"" + str(out[fullkeyname]) + "\",")
+
+            # if the item has at least two commas in it, split it
+            if tables[table][key].count(',') > 0:
+                out[fullkeyname] = list(map(lambda x: x.strip(), tables[table][key].split(",")))
+                print("\"" + keyname + "\":", "\"" + str(out[fullkeyname]) + "\",")
+
+
+    #print("}")
+    return out
 
     
 
 if __name__ == "__main__":
-    parse("test2.pdf", "10GXS13")
+    parse("test2.pdf", "cables/10GXS13", "10GXS13")

requirements.txt

@@ -5,13 +5,16 @@ pypdf2==2.12.1
 alive-progress
 requests
 git+https://github.com/Byeongdulee/python-urx.git
-psycopg2
+meilisearch
 pyyaml
 Flask
 selenium
 sacn
 uptime
 websockets
+numpy
+scipy
+ipywidgets
 
 # Development
 matplotlib

run.py

@@ -89,6 +89,9 @@ def start_server_socket():
 
     while True:
         #print("HI")
+
+        # Handeling Server Requests Loop, will run forever
+
         if not from_server_queue.empty():
             client_id, message = from_server_queue.get()
             fprint(f"Message from client {client_id}: {message}")
@@ -113,7 +116,7 @@ def start_server_socket():
                     case "log":
                         fprint("log message")
                         if call == "send":
-                            fprint("webapp: " + data)
+                            fprint("webapp: " + str(data), sendqueue=to_server_queue)
                         elif call == "request":
                             fprint("")
 
@@ -124,6 +127,21 @@ def start_server_socket():
                         elif call == "request":
                             fprint("")
 
+
+                    case "ping":
+                        fprint("Pong!!!")
+
+                    # Lucas' notes
+                    # Add a ping pong :) response/handler
+                    # Add a get cable response/handler
+                    #       this will tell the robot arm to move
+                    # Call for turning off everything
+
+                    # TODO Helper for converting Python Dictionaries to JSON
+                    # make function: pythonData --> { { "type": "...", "call": "...", "data": pythonData } }
+                            
+                    # to send: to_server_queue.put(("*", "JSON STRING HERE")) # replace * with UUID of client to send to one specific location
+                    
                     case "cable_details":
                         fprint("cable_details message")
                         if call == "send":
@@ -235,7 +253,7 @@ def setup_server(pool):
 
     if camera_ready is False:
         fprint("waiting for " + "Camera initilization" + " to complete...", sendqueue=to_server_queue)
-        camera = process_video.qr_reader(config["cameras"]["banner"]["ip"], config["cameras"]["banner"]["port"])
+        # camera = process_video.qr_reader(config["cameras"]["banner"]["ip"], config["cameras"]["banner"]["port"])
 
     fprint("Camera initialized.", sendqueue=to_server_queue)
 
@@ -262,8 +280,8 @@ def mainloop_server(pool):
         killall()
     counter = counter + 1
 
-    fprint("Looking for QR code...")
-    print(camera.read_qr(30))
+    # fprint("Looking for QR code...")
+    # print(camera.read_qr(30))
 
 def run_loading_app():
     

search.py

@@ -0,0 +1,117 @@
+"""Interactions with the Meilisearch API for adding and searching cables."""
+from meilisearch import Client
+from meilisearch.task import TaskInfo
+from meilisearch.errors import MeilisearchApiError
+import json
+
+DEFAULT_URL = "http://localhost:7700"
+DEFAULT_APIKEY = "fluffybunnyrabbit" # I WOULD RECOMMEND SOMETHING MORE SECURE
+DEFAULT_INDEX = "cables"
+DEFAULT_FILTERABLE_ATTRS = ["partnum", "uuid", "position"] # default filterable attributes
+
+
+class JukeboxSearch:
+    """Class for interacting with the Meilisearch API."""
+    def __init__(self,
+                 url: str = None,
+                 api_key: str = None,
+                 index: str = None,
+                 filterable_attrs: list = None):
+        """Connect to Meilisearch and perform first-run tasks as necessary.
+
+        :param url: Address of the Meilisearch server. Defaults to ``http://localhost:7700`` if unspecified.
+        :param api_key: API key used to authenticate with Meilisearch. It is highly recommended to set this as something
+        secure if you can access this endpoint publicly, but you can ignore this and set Meilisearch's default API key
+        to ``fluffybunnyrabbit``.
+        :param index: The name of the index to configure. Defaults to ``cables`` if unspecified.
+        :param filterable_attrs: List of all the attributes we want to filter by."""
+        # connect to Meilisearch
+        url = url or DEFAULT_URL
+        api_key = api_key or DEFAULT_APIKEY
+        filterable_attrs = filterable_attrs or DEFAULT_FILTERABLE_ATTRS
+        self.index = index or DEFAULT_INDEX
+        self.client = Client(url, api_key)
+        # create the index if it does not exist already
+        try:
+            self.client.get_index(self.index)
+        except MeilisearchApiError as _:
+            self.client.create_index(self.index)
+        # make a variable to easily reference the index
+        self.idxref = self.client.index(self.index)
+
+        # update filterable attributes if needed
+        self.update_filterables(filterable_attrs)
+
+    def add_document(self, document: dict) -> TaskInfo:
+        """Add a cable to the Meilisearch index.
+
+        :param document: Dictionary containing all the cable data.
+        :returns: A TaskInfo object for the addition of the new document."""
+        return self.idxref.add_documents(document)
+
+    def add_documents(self, documents: list):
+        """Add a list of cables to the Meilisearch index.
+
+        :param documents: List of dictionaries containing all the cable data.
+        :returns: A TaskInfo object for the last new document."""
+        taskinfo = None
+        for i in documents:
+            taskinfo = self.add_document(i)
+        return taskinfo
+    
+    def update_filterables(self, filterables: list):
+        """Update filterable attributes and wait for database to fully index. If the filterable attributes matches the
+        current attributes in the database, don't update (saves reindexing).
+        
+        :param filterables: List of all filterable attributes"""
+
+        existing_filterables = self.idxref.get_filterable_attributes()
+        if len(set(existing_filterables).difference(set(filterables))) > 0:
+            taskref = self.idxref.update_filterable_attributes(filterables)
+
+            self.client.wait_for_task(taskref.index_uid)
+
+    def search(self, query: str, filters: str = None):
+        """Execute a search query on the Meilisearch index.
+        
+        :param query: Seach query
+        :param filters: A meilisearch compatible filter statement.
+        :returns: The search results dict. Actual results are in a list under "hits", but there are other nice values that are useful in the root element."""
+        if filters:
+            q = self.idxref.search(query, {"filter": filters})
+        else:
+            q = self.idxref.search(query)
+        return q
+    
+    def _filter_one(self, filter: str):
+        """Get the first item to match a filter.
+        
+        :param filter: A meilisearch compatible filter statement.
+        :returns: A dict containing the results; If no results found, an empty dict."""
+        q = self.search("", filter)
+        if q["estimatedTotalHits"] != 0:
+            return ["hits"][0]
+        else:
+            return dict()
+
+    def get_position(self, position: str):
+        """Get a part by position.
+        
+        :param partnum: The position to search for."""
+        return self._filter_one(f"position = {position}")
+    
+    def get_uuid(self, uuid: str):
+        """Get a specific UUID.
+        
+        :param uuid: The UUID to search for."""
+        return self._filter_one(f"uuid = {uuid}")
+
+    def get_partnum(self, partnum: str):
+        """Get a specific part number.
+        
+        :param partnum: The part number to search for."""
+        return self._filter_one(f"partnum = {partnum}")
+
+# entrypoint
+if __name__ == "__main__":
+    jbs = JukeboxSearch()

source.fish

@@ -0,0 +1 @@
+source venv/bin/activate.fish

source.sh

@@ -0,0 +1 @@
+source venv/bin/activate

test.py

@@ -0,0 +1,106 @@
+print("\u001b[37m")
+
+class Ring:
+    def __init__(self) -> None:
+        self.leds = [0] * 24
+        self.id = 0
+        self.dirty = False
+
+    def __iter__(self) -> iter:
+        yield from self.leds
+
+    def __repr__(self) -> str:
+        return f"Ring<id={self.id}, led_state={' '.join(list(map(lambda x: str(x+1), self.leds)))}, dirty={self.dirty}>"
+
+    def __add__(self, other):
+        self.leds.extend(other)
+        return self
+
+    def __bool__(self):
+        return self.dirty
+
+    def __getitem__(self, index):
+        return self.leds[index]
+    
+    def __setitem__(self, index, value):
+        ivalue = self.leds[index]
+        if ivalue != value:
+            self.dirty = True
+            self.leds[index] = value
+    
+    def __getattr__(self, name):
+        import word2num
+        name = int(word2num.word2num(name))
+        print(name)
+        if 0 <= name < len(self.leds):
+            return self.leds[name]
+        
+
+
+a = Ring()
+print(a)
+b = Ring()
+b.leds[2] = 3
+
+print(a + b)
+
+b.active = True
+
+if b:
+    print("Bexist")
+
+c = [a, b, b, a, a]
+
+d = list(filter(lambda x: bool(x), c))
+
+print(d)
+
+for i, ring in enumerate(c):
+    ring[0] = i
+    print(ring)
+
+print(a, b)
+
+print(f"\u001b[32m{a}")
+print(f"\u001b[37ma")
+
+print(getattr(a, "twenty two"))
+
+# eval(f"getattr(a,\"{input()}\")")
+
+
+# a = r"wow this string is cursed; for example \n"
+
+
+# SEARCHDATA=r"""{ "q": "{QUERY}", "sortCriteria": "relevancy", "numberOfResults": "250", "sortCriteria": "@catalogitemwebdisplaypriority ascending", "searchHub": "products-only-search", "pipeline": "Site Search", "maximumAge": "900000", "tab": "products-search", "locale": "en", "aq": "(NOT @z95xtemplate==(ADB6CA4F03EF4F47B9AC9CE2BA53FF97,FE5DD82648C6436DB87A7C4210C7413B)) ((@syssource==\"website_001002_catalog_index-rg-nc-prod-sitecore-prod\" @catalogitemprimarycategorypublished==true)) ((@catalogitemregionavailable=Global) (@z95xlanguage==en))", "cq": "((@z95xlanguage==en) (@z95xlatestversion==1) (@source==\"Coveo_web_index - rg-nc-prod-sitecore-prod\")) OR (@source==(\"website_001002_catalog_index-rg-nc-prod-sitecore-prod\",\"website_001002_Category_index-rg-nc-prod-sitecore-prod\"))", "firstResult": "0" }, "categoryFacets": "[{\"field\":\"@catalogitemcategories\",\"path\":[],\"injectionDepth\":1000,\"maximumNumberOfValues\":6,\"delimitingCharacter\":\"|\"}]", "facetOptions": "{}", "groupBy": "    [{\"field\":\"@contenttype\",\"maximumNumberOfValues\":6,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[\"Products\"],\"queryOverride\":\"{QUERY}\",\"advancedQueryOverride\":\"(NOT @z95xtemplate==(ADB6CA4F03EF4F47B9AC9CE2BA53FF97,FE5DD82648C6436DB87A7C4210C7413B)) ((((((((@z95xpath=3324AF2D58F64C0FB725521052F679D2 @z95xid<>3324AF2D58F64C0FB725521052F679D2) ((@z95xpath=C292F3A37B3A4E6BAB345DF87ADDE516 @z95xid<>C292F3A37B3A4E6BAB345DF87ADDE516) @z95xtemplate==E4EFEB787BDC4B1A908EFC64D56CB2A4)) OR ((@z95xpath=723501A864754FEEB8AE377E4C710271 @z95xid<>723501A864754FEEB8AE377E4C710271) ((@z95xpath=600114EAB0E5407A84AAA9F0985B6575 @z95xid<>600114EAB0E5407A84AAA9F0985B6575) @z95xtemplate==2BE4FD6B3B2C49EBBD9E1F6C92238B05))) OR (@syssource==\\"website_001002_catalog_index-rg-nc-prod-sitecore-prod\\" @catalogitemprimarycategorypublished==true)) OR ((@z95xpath=3324AF2D58F64C0FB725521052F679D2 @z95xid<>3324AF2D58F64C0FB725521052F679D2) @z95xpath<>C292F3A37B3A4E6BAB345DF87ADDE516)) OR @syssource==\\"website_001002_Category_index-rg-nc-prod-sitecore-prod\\") NOT @z95xtemplate==(ADB6CA4F03EF4F47B9AC9CE2BA53FF97,FE5DD82648C6436DB87A7C4210C7413B))) ((@catalogitemregionavailable=Global) (@z95xlanguage==en) OR (@contenttype=(Blogs,Resources,Other)) (NOT @ez120xcludefromcoveo==1))\",\"constantQueryOverride\":\"((@z95xlanguage==en) (@z95xlatestversion==1) (@source==\\"Coveo_web_index - rg-nc-prod-sitecore-prod\\")) OR (@source==(\\"website_001002_catalog_index-rg-nc-prod-sitecore-prod\\",\\"website_001002_Category_index-rg-nc-prod-sitecore-prod\\"))\"},{\"field\":\"@catalogitembrand\",\"maximumNumberOfValues\":6,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]},{\"field\":\"@catalogitemenvironment\",\"maximumNumberOfValues\":6,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]},{\"field\":\"@catalogitemregionalavailability\",\"maximumNumberOfValues\":6,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]},{\"field\":\"@prez45xtez120xt\",\"maximumNumberOfValues\":5,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]},{\"field\":\"@tags\",\"maximumNumberOfValues\":4,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]},{\"field\":\"@facetassettype\",\"maximumNumberOfValues\":3,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]},{\"field\":\"@facetbrand\",\"maximumNumberOfValues\":3,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]},{\"field\":\"@facetmarket\",\"maximumNumberOfValues\":6,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]},{\"field\":\"@facetsolution\",\"maximumNumberOfValues\":6,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]},{\"field\":\"@facetsearchcontentpagetype\",\"maximumNumberOfValues\":6,\"sortCriteria\":\"occurrences\",\"injectionDepth\":1000,\"completeFacetWithStandardValues\":true,\"allowedValues\":[]}]" }"""
+
+# QUERY = "AAAAAAAAAAAA"
+
+# b = SEARCHDATA.replace(r"{QUERY}", QUERY)
+
+q = [i * 2 for i in range(10)]
+
+d = {a : b for a,b in enumerate(q)}
+
+print(q)
+
+print(d)
+
+def stalin_sort(a):
+    b = sum(a)
+    b /= len(a)
+    return [b for _ in range(len(a))]
+
+def mao_sort(a):
+    i = 0
+    while i < len(a) - 1:
+        if a[i+1] < a[i]:
+            del a[i]
+        else:
+            i += 1
+    return a
+
+print(stalin_sort(list(range(10))))
+print(mao_sort([1, 3, 2, 4, 5, 8, 7, 6, 9]))
+
+# i l

ur5_control.py

@@ -1,6 +1,8 @@
 import urx
 import math3d as m3d
+from scipy.optimize import fsolve
 import math
+import numpy as np
 import time
 import os
 import logging
@@ -8,6 +10,9 @@ from urx.robotiq_two_finger_gripper import Robotiq_Two_Finger_Gripper
 import sys
 from util import fprint
 
+
+
+
 rob = None
 
 
@@ -45,7 +50,7 @@ def init(ip):
     time.sleep(0.2)
     fprint("UR5 ready.")
 
-def set_pos_abs(x, y, z, xb, yb, zb):
+def set_pos_abs(x, y, z, xb, yb, zb, threshold=None):
     global rob
     new_orientation = m3d.Transform()
     new_orientation.orient.rotate_xb(xb)  # Replace rx with the desired rotation around X-axis
@@ -60,7 +65,7 @@ def set_pos_abs(x, y, z, xb, yb, zb):
     new_trans.pos.y = y
     new_trans.pos.z = z
     #rob.speedj(0.2, 0.5, 99999)
-    rob.set_pose(new_trans, acc=2, vel=2, command="movej")  # apply the new pose
+    rob.set_pose(new_trans, acc=2, vel=2, command="movej", threshold=threshold)  # apply the new pose
 
 def set_pos_rel_rot_abs(x, y, z, xb, yb, zb):
     global rob
@@ -80,21 +85,278 @@ def set_pos_rel_rot_abs(x, y, z, xb, yb, zb):
     #rob.speedj(0.2, 0.5, 99999)
     rob.set_pose(new_trans, acc=0.1, vel=0.4, command="movej")  # apply the new pose
 
+def set_pos_abs_rot_rel(x, y, z, xb, yb, zb):
+    global rob
+    new_orientation = m3d.Transform()
+    new_orientation.orient.rotate_xb(xb)  # Replace rx with the desired rotation around X-axis
+    new_orientation.orient.rotate_yb(yb)  # Replace ry with the desired rotation around Y-axis
+    new_orientation.orient.rotate_zb(zb)  # Replace rz with the desired rotation around Z-axis
+
+    # Get the current pose
+    trans = rob.getl()
+    
+    # Apply the new orientation while keeping the current position
+    new_trans = m3d.Transform(new_orientation.orient, m3d.Vector(trans[0:3]))
+    new_trans.pos.x = x
+    new_trans.pos.y = y
+    new_trans.pos.z = z
+    #rob.speedj(0.2, 0.5, 99999)
+    rob.set_pose(new_trans, acc=0.1, vel=0.4, command="movej")  # apply the new pose
 
 
+def is_safe_move(start_pose, end_pose, r=0.25):
+    start_x, start_y = (start_pose[0], start_pose[1])
+    end_x, end_y = (end_pose[0], end_pose[1])
+
+    try:
+        m = (end_y-start_y)/(end_x-start_x)
+        b = start_y - m*start_x
+        # print('m = y/x =', m)
+        # print('b =', b)
+    except:
+        m = (end_x-start_x)/(end_y-start_y)
+        b = start_x - m*start_y
+        # print('m = x/y =', m)
+        # print('b =', b)
+    
+    return r**2 - b**2 + m**2 * r**2 < 0
+
+def cartesian_to_polar(x, y):
+    r = np.sqrt(x**2 + y**2)
+    theta = np.arctan2(y, x)
+    return r, theta
+
+def polar_to_cartesian(r, theta):
+    x = r * np.cos(theta)
+    y = r * np.sin(theta)
+    return x, y
+
+
+def move_to_polar(start_pos, end_pos):
+    global rob
+
+    # Convert to polar coordinates
+    start_r, start_theta = cartesian_to_polar(start_pos[0], start_pos[1])
+    end_r, end_theta = cartesian_to_polar(end_pos[0], end_pos[1])
+
+    # Interpolate for xy (spiral arc)
+    n_points = 30
+    r_intermediate = np.linspace(start_r, end_r, n_points)
+    theta_intermediate = np.linspace(start_theta, end_theta, n_points)
+
+    # Interpolate for z (height)
+    start_z = start_pos[2]
+    end_z = end_pos[2]
+
+    z_intermediate = np.linspace(start_z, end_z, n_points)
+
+    # Interpolate for rz (keep tool rotation fixed relative to robot)
+
+
+    curr_rot = rob.getl()
+
+    theta_delta = theta_intermediate[1]-theta_intermediate[0]
+    
+    rx_intermediate = [curr_rot[5] + theta_delta*i for i in range(n_points)]
+
+    # curr_rot = rob.getj()
+    # start_rz = curr_rot[5]
+    # rot = end_theta - start_theta
+    # end_base_joint = curr_rot[0]-start_theta + rot
+
+    # end_rz = curr_rot[0] + rot
+    # # rob.movel([*polar_to_cartesian(end_r, end_theta), *rob.getl()[2:]], acc=2, vel=2)
+
+    # print('start_theta = ', math.degrees(start_theta))
+    # print('end_theta = ', math.degrees(curr_rot[0]-start_theta+rot))
+    # print('start_rz =', math.degrees(start_rz))
+    # print('rot =', math.degrees(rot))
+    # print('end_rz =', math.degrees(end_rz))
+
+    # rz_intermediate = np.linspace(start_rz, end_rz, n_points)
+
+    # Convert back to cartesian coordinates
+    curr_pos = rob.getl()
+
+    intermediate_points = [[*polar_to_cartesian(r, theta), z, *curr_pos[3:]]
+                            for r, theta, z, rx in zip(r_intermediate, 
+                                                       theta_intermediate, 
+                                                       z_intermediate, 
+                                                       rx_intermediate)]
+
+    # Move robot
+    rob.movels(intermediate_points, acc=2, vel=2, radius=0.1)
+    
+
+    return rx_intermediate
+
+def move_to_home():
+    global rob
+
+    # Home position in degrees
+    home_pos = [0.10421807948612624, 
+                -2.206111555015423, 
+                1.710679229503537, 
+                -1.075834511928354, 
+                -1.569301366430687, 
+                1.675098295930943]
+
+    # Move robot
+    rob.movej(home_pos, acc=2, vel=2)
+
+def normalize_degree(theta):
+    # Normalizes degree theta from -1.5pi to 1.5pi
+    multiplier = 1
+    normalized_theta = theta % (math.pi * multiplier)
+    
+    # Maintain the negative sign if the original angle is negative
+    if theta < 0:
+        normalized_theta -= math.pi * multiplier
+
+    # Return angle
+    return normalized_theta
+
+
+def get_joints_from_xyz_rel(x, y, z, rx=0, ry=-math.pi/2, rz=0, initial_guess = (math.pi/2, math.pi/2, 0)):
+    # Get limbs and offsets
+    offset_x, offset_y, offset_z = (0, 0, 0.14)     # Tool offset
+    l_bs, l1, l2, l3, l_wt = (0.1333, .425, .39225, .1267, .0997)    # Limb lengths
+    #l3=0.15
+    
+    # Calculate base angle and r relative to shoulder joint
+    def calculate_theta(x, y, a):
+        # Calculate if we need the + or - in our equations
+        if (x>-a and y>=0) or (x>a and y<0):
+            flip = 1
+        elif (x<-a and y>=0) or (x<a and y<0):
+            flip = -1
+        else: 
+            # Critical section (x=a, or x=-a). Infinite slope
+            # Return 0 or 180 depending on sign
+            return math.atan2(y, 0)
+        
+        # Calculate tangent line y = mx + b
+        m = (x*y - math.sqrt(x*x*y*y-(x*x-a*a)*(y*y-a*a)))/(x*x-a*a)
+        b = flip * a * math.sqrt(1+m*m)
+
+        # Calculate equivalent tangent point on circle
+        cx = (-flip*m*b)/(1+m*m)
+        cy = m*cx + flip*b
+
+        # Calculate base angle, make angle negative if flip=1
+        theta = math.atan2(cy, cx) + (-math.pi if flip==1 else 0)
+
+        return theta 
+    
+    base_theta = calculate_theta(x, y, l_bs)
+    cx, cy = l_bs*math.cos(base_theta), l_bs*math.sin(l_bs)
+    r = math.sqrt((x-cx)**2 + (y-cy)**2) 
+
+
+    # Formulas to find out joint positions for (r, z)
+    def inv_kin_r_z(p):
+        a, b, c = p            
+
+        return (l1*math.cos(a) + l2*math.cos(a-b) + l3*math.cos(a-b-c) - r, # r
+                l1*math.sin(a) + l2*math.sin(a-b) - l3*math.sin(a-b-c) - (l3*math.sin(a-b-c)) - (z + offset_z),  # z
+                a-b-c) # wrist angle
+
+
+    # Normalize angles
+    base, shoulder, elbow, wrist1 = [normalize_degree(deg) for deg in [base_theta, *fsolve(inv_kin_r_z, initial_guess)]]
+
+    # Return result
+    return base, shoulder, elbow, wrist1, ry, rz
+
+def get_joints_from_xyz_abs(x, y, z, rx=0, ry=-math.pi/2, rz=math.pi/2):
+    joints = get_joints_from_xyz_rel(x, y, z, rx, ry, rz)
+
+    # Joint offsets
+    # Base, Shoulder, Elbow, Wrist
+    inverse = [1, -1, 1, 1, 1, 1]
+    offsets = [-math.pi/2, 0, 0, -math.pi/2, 0, 0]
+
+    # Return adjusted joint positions
+    return [o+j*i for j, o, i in zip(joints, offsets, inverse)]
 
 if __name__ == "__main__":
     
     #rob.movej((0, 0, 0, 0, 0, 0), 0.1, 0.2)
     #rob.movel((x, y, z, rx, ry, rz), a, v)
     init("192.168.1.145")
-    fprint("Current tool pose is: ",  rob.getl())
-    #set_pos_rel_rot_abs(0, 0, -0.2, math.pi, 0, -math.pi)
-    set_pos_abs(0.3, -0.2, 0.5, math.pi, 0, -math.pi)
-    set_pos_abs(0, 0.2, 0.6, math.pi, 0, -math.pi)
-    set_pos_abs(-0.5, -0.2, 0.4, math.pi, 0, -math.pi)
-    #set_pos_rel_rot_abs(0, 0, 0, math.pi, 0, -math.pi)
-    fprint("Current tool pose is: ",  rob.getl())
+    print("Current tool pose is: ",  rob.getl())
+    move_to_home()
+
+    home_pose = [-0.4999999077032916, 
+               -0.2000072960336574, 
+               0.40002172976662786, 
+               0, 
+               -3.14152741295329, 
+               math.radians(62)]
+
+    # time.sleep(.5)
+
+    p1 = [0,
+
+        0.6,
+        .4,
+        0.2226,
+        3.1126,
+        0.0510]
+    
+    p2 = [0.171,
+        -0.115,
+        0.2,
+        0.2226,
+        3.1126,
+        0.0510]
+
+    curr_pos = rob.getl()
+    # up/down, 
+    # tool rotation
+    # tool angle (shouldn't need)
+    # rob.set_pos(p1[0:3], acc=0.5, vel=0.5)
+
+    # set_pos_abs(*home_pose)
+
+
+    
+    angles = get_joints_from_xyz_abs(-0.7, 0, 0)
+    rob.movej(angles, acc=2, vel=2)
+
+    # joints = []
+    # for i in np.linspace(-0.3, -0.7, 50):
+    #     joints.append(get_joints_from_xyz_abs(i, 0, 0))
+    # rob.movejs(joints, acc=2, vel=2)
+
+    # time.sleep(5)
+
+
+    # angles = get_joints_from_xyz_abs(0, -0.6, 0)
+    # rob.movej(angles, acc=2, vel=2)
+    
+
+
+    # set_pos_abs(*p1)
+    # move = move_to_polar(p1, p2)
+
+
+    # for p in move:
+    #     print(math.degrees(p))
+    # print("Safe? :", is_safe_move(p1, p2))
+
+
+    # #set_pos_rel_rot_abs(0, 0, -0.2, math.pi, 0, -math.pi)
+    # set_pos_abs(0.3, -0.2, 0.5, math.pi, 0, -math.pi)
+    # set_pos_abs(0, 0.2, 0.6, math.pi, 0, -math.pi)
+    # set_pos_abs(-0.5, -0.2, 0.4, math.pi, 0, -math.pi)
+    # #set_pos_rel_rot_abs(0, 0, 0, math.pi, 0, -math.pi)
+
+    # print("Current tool pose is: ",  rob.getl())
+    # print("getj(): ",  rob.getj())
+
+    # move_to_home()
+
     rob.stop()
     os.kill(os.getpid(), 9) # dirty kill of self
     sys.exit(0)

util.py

@@ -123,7 +123,7 @@ class Logger(object):
         self.terminal = sys.stdout
 
     def write(self, message):
-        self.log.write(message)
+        #self.log.write(message)
         #close(filename)
         #self.log = open(filename, "a")
         try:

venv-setup.sh

@@ -1,6 +1,7 @@
 #!/bin/sh
+# change this to #!/bin/bash for windows
 
-python -m venv ./venv
+python3 -m venv ./venv
 source ./venv/bin/activate
 
 pip install --upgrade pip

websocket_test.html

@@ -1,8 +1,53 @@
 <!DOCTYPE html>
 <html>
+
 <head>
     <title>WebSocket Test</title>
+
+    <style>
+        footer {
+            background-color: #333;
+            color: #fff;
+            text-align: center;
+            padding: 10px 0;
+            position: fixed;
+            bottom: 0;
+            width: 100%;
+            display: flex;
+            justify-content: space-around;
+        }
+
+        .service-box {
+            width: 150px;
+            padding: 10px;
+            border-radius: 5px;
+        }
+
+        .service-up {
+            background-color: green;
+        }
+
+        .service-down {
+            background-color: red;
+        }
+    </style>
+
+
     <script>
+
+        // class Service {
+        //     constructor(name, status) {
+        //         this.name = name
+        //         this.status = status
+        //     }
+        // }
+
+        var updatedTime = new Date();
+        // Initial status of services
+        // var serviceA = new Service("234234", 'down');
+        // var serviceBStatus = 'down';
+        // var serviceCStatus = 'down';
+
         document.addEventListener("DOMContentLoaded", function () {
             // Create WebSocket connection.
             const socket = new WebSocket('ws://localhost:9000');
@@ -10,6 +55,7 @@
             // Connection opened
             socket.addEventListener('open', function (event) {
                 console.log("Connected to WebSocket server");
+                updatedTime = new Date();
             });
 
             // Listen for messages
@@ -19,6 +65,7 @@
                 let message = document.createElement('li');
                 message.textContent = "Received: " + event.data;
                 messages.appendChild(message);
+                updatedTime = new Date();
             });
 
             // Send a message to the server
@@ -28,15 +75,82 @@
                 console.log('Message sent', message);
             }
 
+            // This function just sends a ping to make sure the server is there and it is able to responds
+            function ping() {
+                let message = `{ "call": "send", "type": "log", "data": "This is a ping!!" }`;
+                socket.send(message);
+                console.log('Message sent', message);
+            }
+            setInterval(ping, 1500);
+
+            // setInterval(() => {
+            //     updateServiceStatus('serviceA', 'down');
+            // }, 2000);
+
+
             // Bind send message function to button click
             document.getElementById('sendMessage').addEventListener('click', sendMessage);
         });
     </script>
 </head>
+
 <body>
     <h2>WebSocket Test</h2>
-    <input type="text" id="messageInput" placeholder="Type a message...">
+    <textarea rows="4" cols="50" id="messageInput" placeholder="Type a message..."> </textarea>
     <button id="sendMessage">Send Message</button>
+    <p>Example JSON</p>
+    <p>{ "type": "cable_map", "call": "request", "data": { } }</p>
+    <p>{ "type": "log", "call": "send", "data": "123123" }</p>
+
+    <p>Messages/Logs</p>
     <ul id="messages"></ul>
+
+    <footer>
+        <!-- <div id="serviceA" class="service-box"></div>
+        <div id="serviceB" class="service-box"></div>
+        <div id="serviceC" class="service-box"></div> -->
+        <div id="clock"></div>
+
+    </footer>
+
+    <script>
+        // // Function to update service status
+        // function updateServiceStatus(service) {
+        //     // serviceId, status
+        //     var serviceElement = document.getElementById(service.serviceId);
+        //     // updateClock();
+
+        //     if (service.status === 'up') {
+        //         serviceElement.innerHTML = '<h3>' + service.serviceId + '</h3><p>Running</p>';
+        //         serviceElement.classList.remove('service-down');
+        //         serviceElement.classList.add('service-up');
+        //     } else {
+        //         serviceElement.innerHTML = '<h3>' + service.serviceId + '</h3><p>Down</p>';
+        //         serviceElement.classList.remove('service-up');
+        //         serviceElement.classList.add('service-down');
+        //     }
+        // }
+
+
+
+        // // Update service statuses
+        // updateServiceStatus('node.js (for this page)', serviceAStatus);
+        // updateServiceStatus('Python WebSocket', serviceBStatus);
+        // updateServiceStatus('serviceC', serviceCStatus);
+
+        // Function to update clock
+        function updateClock() {
+            var now = new Date();
+            now = now.getTime() - updatedTime.getTime();
+            // console.log(now)
+            document.getElementById('clock').textContent = 'Milliseconds Since Update: ' + now.toString().padStart(6, '0');
+        }
+
+        // Update clock every second
+        setInterval(updateClock, 100);
+
+    </script>
+
 </body>
+
 </html>