sort_by_dependency.hs

import Data.List                                                                
                                                                                
type Dict = [(String, String)]                                                  
                                                                                
views :: Dict                                                                   
views = [ ("foo", "select bar")                                                 
        , ("bar", "select shoe")                                                
        , ("shoe", "select none")                                               
        , ("cat", "select foo")                                                 
        , ("dog", "select mouse")                                               
        , ("mouse", "select cat")                                               
        ]                                                                       
                                                                                
answer = sortByDependency views []                                              
                                                                                
sortByDependency :: Dict -> Dict -> Dict                                        
sortByDependency [] partial = partial                                           
sortByDependency initial partial = sortByDependency remaining result            
  where                                                                         
    result = partial ++ excludeDependencies initial                             
    remaining = filter (\(k, v) -> k `notElem` (map fst result)) initial        
                                                                                
                                                                                
excludeDependencies :: Dict -> Dict                                              
excludeDependencies d =                                                         
    filter (\(k, v) -> not . any (`isInfixOf` v) $ map fst d) d

sort_by_dependency.py

from django.utils.datastructures import SortedDict

views = SortedDict()
views['foo'] = 'select bar'
views['bar'] = 'select shoe'
views['shoe'] = 'select none'
views['cat'] = 'select foo'
views['dog'] = 'select mouse'
views['mouse'] = 'select cat'


def answer():
    """ :rtype: SortedDict """
    return sort_by_dependency(views, SortedDict())


def sort_by_dependency(initial, partial):
    """
    :type initial: SortedDict
    :type partial: SortedDict
    :rtype: SortedDict
    """
    if not initial:
        return partial
    result = SortedDict(partial.items() + exclude_dependencies(initial).items())
    remaining = SortedDict((k, v) for k, v in initial.items()
                           if k not in result.keys())
    return sort_by_dependency(remaining, result)


def exclude_dependencies(d):
    """
    :type d: SortedDict
    :rtype: SortedDict
    """
    return SortedDict((k, v) for k, v in d.items()
                      if not any(k2 in v for k2 in d.keys()))

print answer()