partsdb

helpers.py (5676B)

---

 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # vim:fenc=utf-8
 
 import json
 import subprocess
 import tempfile
 import time
 
 
 def print_parts_list(parts, output="full"):
     if output == "short":
         _list_ascii_short(parts)
     if output == "full":
         _list_ascii(parts)
     if output == "json":
         _list_json(parts)
 
 
 def _list_ascii(parts):
     # max takes an iterable and key is a function where iterables are
     # passed and comparison performed, so we look at the longest desc to
     # get the lenght of the field.  We also check if the header is longer,
     # the result is whatever is longer
     l_pn = len(max(parts, key=lambda k: len(k["pn"]))["pn"])
     l_cat = len(max(parts, key=lambda k: len(k["cname"]))["cname"])
     l_man = len(max(parts, key=lambda k: len(k["manufacturer"]))["manufacturer"])
     l_desc = len(max(parts, key=lambda k: len(k["description"]))["description"])
     l_cat = l_cat if l_cat > len("Category") else len("Category")
     l_man = l_man if l_man > len("Manufacturer") else len("Manufacturer")
     l_desc = l_desc if l_desc > len("Description") else len("Description")
 
     header = (
         f"| {'ID':5} | {'PN':{l_pn}} | "
         f"{'Category':{l_cat}} | "
         f"{'Manufacturer':{l_man}} | "
         f"{'Description':{l_desc}} | "
         f"{'Type':4} | "
         f"{'Footp':6} | "
         f"{'Qty':4} |"
     )
     for i, p in enumerate(parts):
         if i % 25 == 0:
             print("-" * len(header))
             print(header)
             print("-" * len(header))
         print(
             f"| {p['id']:<5} | {p['pn']:{l_pn}} | "
             f"{p['cname']:{l_cat}} | "
             f"{_sanitize_value(p['manufacturer']):{l_man}} | "
             f"{_sanitize_value(p['description']):{l_desc}} | "
             f"{_sanitize_value(p['part_type'])[0:3]:4} | "
             f"{_sanitize_value(p['footprint'])[0:5]:6} | "
             f"{p['quantity']:4} |"
         )
 
 
 def _list_ascii_short(parts):
     header = (
         f"| {'ID':4} | "
         f"{'Category':8} | "
         f"{'PN':10} | "
         f"{'Manufacturer':16} | "
         f"{'Description':25} |"
     )
     for i, p in enumerate(parts):
         if i % 25 == 0:
             print("-" * 79)
             print(header)
             print("-" * 79)
         print(
             f"| {p['id']:<4} | "
             f"{p['cname'][0:7]:8} | "
             f"{_sanitize_value(p['pn'])[0:9]:10} | "
             f"{_sanitize_value(p['manufacturer'])[0:15]:16} | "
             f"{_sanitize_value(p['description'])[0:24]:25} |"
         )
 
 
 def _list_json(parts):
     p = [dict(zip(part.keys(), part)) for part in parts]
     print(json.dumps({"parts": p}))
 
 
 def print_part(p, history, output="full"):
     if output == "full":
         _part_ascii(p, history)
     if output == "json":
         _part_json(p, history)
 
 
 def _part_ascii(p, history):
     print(f"PN: {p['pn']}\tManufacturer: {p['manufacturer']}\tMPN: {p['mpn']}")
     print(
         f"Category: {p['cat']}\tType: {p['part_type']}" f"\tFootprint: {p['footprint']}"
     )
     print(f"Storage: {p['storage']}")
     print(f"Created: {p['insert_date']}" f"\tUpdated: {p['update_date']}\n")
     print(f"Description:\n{p['description']}\n")
     print(f"Specs:\n{p['specs']}")
 
     if p["datasheet"] is not None:
         print("This part has a datasheet available.")
     if p["image"] is not None:
         print("This part has an image available.")
 
     print(f"\nQuantity: {p['quantity']}")
     # here should go the historical data.
     if history:
         print("History:")
         for h in history:
             print(f"{h['insert_date']} | " f"{h['movement']:4} | " f"{h['mcomment']}")
 
 
 def _part_json(part, history):
     part = dict(zip(part.keys(), part))
     # remove bytes data if present.  For now is useless in this output.
     del part["datasheet"]
     del part["image"]
 
     part["history"] = [dict(zip(h.keys(), h)) for h in history]
 
     print(json.dumps({"part": part}))
 
 
 def _sanitize_value(value):
     if value is None:
         return "-"
     return value
 
 
 def open_file(content, extension):
     with tempfile.NamedTemporaryFile(suffix=extension) as f:
         f.write(content)
         subprocess.Popen(["xdg-open", f.name], start_new_session=True)
         time.sleep(2)
 
 
 def html_main_index(dest_folder, categories, storages, env):
     tpl = env.get_template("index.html")
     with open(f"{dest_folder}/index.html", "w") as f:
         f.write(tpl.render(cat=categories, sto=storages))
 
 
 def html_category_index(dest_folder, category, parts, env):
     tpl = env.get_template("cat.html")
     with open(f"{dest_folder}/cat_list_{category['id']}.html", "w") as f:
         f.write(tpl.render(category=category, parts=parts))
 
 
 def html_storage_index(dest_folder, storage, parts, env):
     tpl = env.get_template("storage.html")
     with open(f"{dest_folder}/storage_{storage['id']}.html", "w") as f:
         f.write(tpl.render(storage=storage, parts=parts))
 
 
 def html_part(dest_folder, part, part_history, env):
     tpl = env.get_template("part.html")
     with open(f"{dest_folder}/part_{part['id']}.html", "w") as f:
         f.write(tpl.render(part=part, history=part_history))
 
 
 def html_css(dest_folder, env):
     tpl = env.get_template("style.css")
     with open(f"{dest_folder}/style.css", "w") as f:
         f.write(tpl.render())
 
 
 def html_attachments(dest_folder, part_id, datasheet, image):
     if datasheet["datasheet"] is not None:
         with open(f"{dest_folder}/part_datasheet_{part_id}.pdf", "wb") as f:
             f.write(datasheet["datasheet"])
     if image["image"] is not None:
         with open(f"{dest_folder}/part_image_{part_id}.jpg", "wb") as f:
             f.write(image["image"])