sle118
commented
3 months ago Adding on to this. Knowing that I probably bastardized bit your work, I did make a change to blindly go after aliases to handle the parameters:
class ApiPartProcessor:
members = get_config().get("choice_format","MPN,quantity_available,price_breaks,manufacturer,Package Type,SKU,supplier_link")
def __init__(self,parameter_map) -> None:
self._parameter_map = parameter_map
def normalize(self,sl:list[str]):
max_len = max(len(itm) for itm in sl)
return [itm.ljust(max_len) for itm in sl]
def extract_nested_attribute(self,obj, path):
"""Recursively extract nested attributes based on a dynamic path."""
if not isinstance(obj, dict):
if hasattr(obj, '__dict__'):
obj = vars(obj)
else:
return ''
parts = path.split('.', 1) # Split at the first dot only
# Handle dictionary key in brackets or direct key
if '[' in parts[0] and ']' in parts[0]:
key = parts[0][parts[0].find('[')+1:parts[0].find(']')]
current_value = obj.get(key, '')
else:
current_value = obj.get(parts[0], '')
if len(parts) == 1: # Base case: no more parts
if current_value == '':
return self.get_parameter(obj,path)
return current_value
else: # Recursive case: more parts to process
if isinstance(current_value, dict) or hasattr(current_value, '__dict__'):
return self.extract_nested_attribute(current_value, parts[1])
else:
return ''
def get_parameter(self, api_part: ApiPart, parm_name: str):
# Use a generator expression instead of a list comprehension
result = api_part['parameters'].get(parm_name,None)
if not result:
gen_expr = (api_part['parameters'].get(alias) for parm in self._parameter_map.get(parm_name, []) for alias in parm.aliases if api_part['parameters'].get(alias) is not None)
# Use next() to get the first item from the generator, or '' if no items are found
result = next(gen_expr, '')
return result
@staticmethod
def format_attribute(attribute, member_name):
"""Format a single attribute based on its type and member name."""
if member_name.endswith("supplier_link") and attribute:
return f"({attribute})"
elif isinstance(attribute, dict):
key, value = next(iter(attribute.items()), ('', ''))
return f"{value} [{key}]" if key else ''
elif isinstance(attribute, list):
return ", ".join(map(str, attribute))
else:
return str(attribute)
def get_formatted_attributes(self,api_parts: list, member_name: str):
"""Get formatted attributes for a given member across all api_parts."""
formatted_attributes = []
for api_part in api_parts:
attribute = self.extract_nested_attribute(api_part, member_name)
formatted_attribute = self.format_attribute(attribute, member_name)
formatted_attributes.append(formatted_attribute)
return self.normalize(formatted_attributes)
def select_api_part(self,api_parts: list):
"""Get formatted choice list."""
formatted_data = {member: self.get_formatted_attributes(api_parts, member) for member in self.members.split(",")}
links = formatted_data.pop("supplier_link", [])
non_link_parts = zip(*(formatted_data[member] for member in formatted_data))
choices = ["{} {}".format(" | ".join(non_link_part), link) for non_link_part, link in zip(non_link_parts, links)]
return choicesand using it:
def select_api_part(self,api_parts: list[ApiPart]):
part_selector = ApiPartProcessor(self.parameter_map)
choices = part_selector.select_api_part(api_parts)I am aware, though, this is just jumping ahead of the mapping process for a given category, but I can live with the consequences locally 😆
30350n
When deciding on which supplier part to use for a given supplier, availability, packaging and pricing are the three things I look at before clicking on a link to check for compatibility and specs, but I suspect that other users could have different requirements. So I wanted to give you my modest contribution for consideration. The idea is to provide users with a way to decide on the choice format themselves, falling back on a default format if not provided.
I am more fluent in C than in Python, so there's a chance this isn't the ideal implementation, but at least it's food for thoughts.
Below is an output example:
It's not ideal as the pricing tear for cut tape doesn't come by default from the digikey wrapper, but inventory and the lowest pricing tier should be a good enough proxy.
Also, I realize that parameters would have to be handled using aliases.