R:  1: Similar lines in 3 files
==certlib:52                   
==factlib:29                   
==repolib:30                   
    def __init__(self, lock=ActionLock()):
        self.lock = lock                  

    def update(self):
        lock = self.lock
        lock.acquire()  
        try:            
            action = UpdateAction()
            return action.perform()
        finally:                   
            lock.release()



Class CertLib, FactLib, RepoLib are identical. Use only one. Or create one parent and those 3 will inherit from it.


R:  1: Similar lines in 2 files                                                                                    
==managerlib:508                                                                                                   
==managerlib_async:58                                                                                              
    def filter_pools(self, compatible, overlapping, uninstalled, text):                                            
        """                                                                                                        
        Return a list of pool hashes, filtered according to the given options.                                     

        This method does not actually hit the server, filtering is done in
        memory.                                                           
        """                                                               
        pools = self.incompatible_pools.values()                          

        if compatible:
            pools = self.compatible_pools.values()

        pool_filter = PoolFilter()

        # Filter out products that are not installed if necessary:
        if uninstalled:                                           
            pools = pool_filter.filter_out_installed(pools)       
        else:                                                     
            pools = pool_filter.filter_out_uninstalled(pools)     

        # Do nothing if set to None:
        if overlapping:             
            pools = pool_filter.filter_out_non_overlapping(pools)
        elif overlapping == False:                               
            pools = pool_filter.filter_out_overlapping(pools)    

        # Filter by product name if necessary:
        if text:                              
            pools = pool_filter.filter_product_name(pools, text)

        return pools

    def merge_pools(self, compatible=True, overlapping=None, uninstalled=False,
            text=None):                                                        
        """                                                                    
        Return a merged view of pools filtered according to the given options. 
        Pools for the same product will be merged into a MergedPool object.    

        Overlapping filter by default is None, meaning the pools will not be
        filtered at all. Use True to filter out pools which do not overlap, 
        or False to filter out pools which do.                              
        """                                                                 
        pools = self.filter_pools(compatible, overlapping, uninstalled, text)
        merged_pools = merge_pools(pools)                                    
        return merged_pools                                                  
R:  1: Similar lines in 2 files                                              
==managerlib:487                                                             
==managerlib_async:36                                                        
        self.all_pools = {}                                                  
        self.compatible_pools = {}                                           
        log.debug("Refreshing pools from server...")                         
        for pool in list_pools(self.backend.uep,                             
                self.consumer.uuid, self.facts, active_on=active_on):        
            self.compatible_pools[pool['id']] = pool                         
            self.all_pools[pool['id']] = pool                                

        # Filter the list of all pools, removing those we know are compatible.
        # Sadly this currently requires a second query to the server.         
        self.incompatible_pools = {}                                          
        for pool in list_pools(self.backend.uep,                              
                self.consumer.uuid, self.facts, all=True, active_on=active_on):
            if not pool['id'] in self.compatible_pools:                        
                self.incompatible_pools[pool['id']] = pool                     
                self.all_pools[pool['id']] = pool                              

        log.debug("found %s pools:" % len(self.all_pools))
        log.debug("   %s compatible" % len(self.compatible_pools))
        log.debug("   %s incompatible" % len(self.incompatible_pools))


There is no need to duplicate so much code of PoolStash class. Create PoolStashBase with common code and in both module change only that part which behave differently.