Help with a reverse dictionary lookup

[bruno at modulix]

rh0dium wrote:
> Hi all,
> 
> I have a dict which looks like this..
> 
> dict={'130nm': {'umc': ['1p6m_1.2-3.3_fsg_ms']},
> '180nm': {'chartered': ['2p6m_1.8-3.3_sal_ms'], 'tsmc':
> ['1p6m_1.8-3.3_sal_log', '1p6m_1.8-3.3_sal_ms']},
> '250nm': {'umc': ['2p6m_1.8-3.3_sal_ms'], 'tsmc':
> ['1p6m_2.2-3.5_sal_log', '1p6m_1.8-3.3_sal_ms']}
> }
> 
> For clarification:
> 130nm,180nm,250nm refer to Nodes
> tsmc,chartered,umc refer to Foundries
> 1p6m..blah, 2p6m..blah refer to Process
> 
> I want a function which can do this:
> 
> nodes = getNodes()
>   should return a list [130nm,180nm,250nm]
> 
> nodes = getNodes(Foundry="umc")
>   should return a list [130nm,250nm]
> 
> nodes = getNodes(Process="2p6m_1.8-3.3_sal_ms")
>   should return a list [180nm,250nm]
> 
> nodes = getNodes(Foundry="umc", Process="2p6m_1.8-3.3_sal_ms")
>   should return a list [250nm]
> 
> nodes = getNodes(Foundry="foo", Process="2p6m_1.8-3.3_sal_ms")
>   should return None
> 
> Obviously I want to extend this to Each area ( i.e., getFoundry(),
> getProcess() ) but I can do that.  I just don't know how to easily do
> this reverse kind of look up?  Can someone help me on this?
> 

Not tested:


import pprint

data={
    '130nm': {
      'umc': ['1p6m_1.2-3.3_fsg_ms']
    },
    '180nm': {
      'chartered': ['2p6m_1.8-3.3_sal_ms'],
      'tsmc': ['1p6m_1.8-3.3_sal_log', '1p6m_1.8-3.3_sal_ms']
    },
    '250nm': {
      'umc': ['2p6m_1.8-3.3_sal_ms'],
      'tsmc':['1p6m_2.2-3.5_sal_log', '1p6m_1.8-3.3_sal_ms']
    }
}


# ----------------------------------------------------------------------
class DataFinder(object):
    def __init__(self, data):
        self._data = data
        self._nodes = data.keys()
        self._foundries_nodes = {}
        self._procs_nodes = {}
        self._procs_foundries = {}

        for node, foundries in data.items():
            for foundry, procs in foundries.items():
                self._foundries_nodes.setdefault(foundry,
                                                 []).append(node)
                for proc in procs:
                    self._procs_nodes.setdefault(proc, []).append(node)
                    self._procs_foundries.setdefault(proc,
                                                     []).append(foundry)
        self._foundries = self._foundries_nodes.keys()
        self._procs = self._procs_foundries.keys()

    # ------------------------------------------------------------------
    # API
    # ------------------------------------------------------------------
    def get_nodes(foundry=None, process=None):
        if foundry is None and process is None:
            return self._nodes[:]
        if process is None:
            return self._get_nodes_for_foundry(foundry)
        if foundry is None:
            return self._get_nodes_for_proc(proc)
        return self._get_nodes_for_foundry_and_proc(foundry, proc)

    def get_foundries(node=None, process=None):
        if node is None and process is None:
            return self._foundries[:]
        if process is None:
            return self._get_foundries_for_node(node)
        if node is None:
            return self._get_foundries_for_proc(node)
        return self._get_foundries_for_node_and_proc(node, proc)

    # TODO : get_procs

    #-------------------------------------------------------------------
    # IMPL
    # ------------------------------------------------------------------
    def _get_foundries_for_node(self, node):
        return self._foundries_nodes.get(node)

    def _get_foundries_for_proc(self, proc):
        return self._procs_foundries.get(proc)

    def _get_foundries_for_node_and_proc(self, node, proc):
        return list(set(self._get_foundries_for_node(node))
                    & set(self._get_foundries_for_proc(proc)))

    # ------------------------------------------------------------------
    def _get_nodes_for_foundry(self, foundry):
        return self._foundries_nodes.get(foundry)

    def _get_nodes_for_proc(self, proc):
        return self._procs_nodes.get(proc)

    def _get_nodes_for_foundry_and_proc(self, foundry, proc):
        return list(set(self._get_nodes_for_foundry(foundry))
                    & set(self._get_nodes_for_proc(proc)))

    # ------------------------------------------------------------------
    # MISC
    # ------------------------------------------------------------------
    def _inspect(self):
        ft = pprint.pformat
        s = """
 ---
+ data :
%s
+ foundries_nodes :
%s
+ procs_nodes :
%s
+ procs_foundries :
%s
        """ % (ft(self._data),
               ft(self._foundries_nodes),
               ft(self._procs_nodes),
               ft(self._procs_foundries)
               )
        print s



HTH
-- 
bruno desthuilliers
python -c "print '@'.join(['.'.join([w[::-1] for w in p.split('.')]) for
p in 'onurb at xiludom.gro'.split('@')])"