Python PersistentDict.get方法代码示例

# 需要导入模块: from durus.persistent_dict import PersistentDict [as 别名]
# 或者: from durus.persistent_dict.PersistentDict import get [as 别名]
class PersistentOrderedDict(Persistent):
    '''
    This class implements the same interface as the `collections.OrderedDict`
    class from the standard library, but uses `persistent` data types for Durus
    support.
    '''
    def __init__(self, items=None):
        self.key_index = PersistentList()
        self.data = PersistentDict()
        if items:
            for k, v in items:
                self[k] = v

    def keys(self):
        return self.key_index[:]

    def __setitem__(self, k, v):
        if k not in self.data:
            self.key_index.append(k)
        self.data[k] = v

    def items(self):
        return [(k, v) for k, v in self.iteritems()]

    def iteritems(self):
        for k in self.key_index:
            yield k, self.data[k]

    def values(self):
        return [v for k, v in self.iteritems()]

    def get(self, key):
        return self.data.get(key)

    def __delitem__(self, key):
        del self.data[key]
        i = self.key_index.index(key)
        del self.key_index[i]

    def __getitem__(self, key):
        return self.data[key]

    def move_to_end(self, key, last=True):
        assert(key in self)
        items = []
        for k, v in self.items():
            if k != key:
                items.append((k, v))
                del self[k]
        if last:
            items.append((key, self[key]))
            del self[key]
        for k, v in items:
            self[k] = v

    def __contains__(self, key):
        return key in self.data

    def __len__(self):
        return len(self.key_index)

# 需要导入模块: from durus.persistent_dict import PersistentDict [as 别名]
# 或者: from durus.persistent_dict.PersistentDict import get [as 别名]
class CUser(Persistent):
    def __init__(self, jid):
        self.jid = jid
        self.items_pending = PersistentList() # [CItem, ...]
        self.config = PersistentDict()
        self.feeds = PersistentDict() # {CFeed: send first notification?}
        
        
    def __len__(self):
        return len(self.feeds)
            
        
    def subs_feed(self, feeditem, sendFirstNoti=False):
        """Add a feed item in 'feeds' dict."""
        if not self.has_feed(feeditem):
            self.feeds[feeditem] = sendFirstNoti
            return True
        return False
        
        
    def unsubs_feed(self, feeditem):
        """Delete a feed item from 'feeds' dict."""
        if self.has_feed(feeditem):
            del self.feeds[feeditem]
            return True
        return False
            
            
    def has_feed(self, feeditem):
        """Search the url feed in 'feeds' dict"""
        for x in self.feeds.keys():
            if x.url == feeditem.url:
                return True
        return False
        
        
    def enableNotifications(self, feeditem):
        self.feeds[feeditem] = True
        
        
    def getNotification(self, feeditem):
        return self.feeds[feeditem]
        
    
    def clear_items(self):
        self.items_pending = PersistentList()
        
        
    def setup(self, action, mode):
        self.config[action] = mode
        return True
        
        
    def getConfig(self, key):
        return self.config.get(key)

# 需要导入模块: from durus.persistent_dict import PersistentDict [as 别名]
# 或者: from durus.persistent_dict.PersistentDict import get [as 别名]
class CFeeds(Persistent):
    def __init__(self):
        self.data = PersistentDict() # {url feed: CFeed}
        
        
    def __getitem__(self, key):
        return self.data[key]

    def __setitem__(self, key, item):
        self.data[key] = item

    def __delitem__(self, key):
        self._p_note_change()
        del self.data[key]

    def get(self, key):
        return self.data.get(key)

    def keys(self):
        return self.data.keys()

    def values(self):
        return self.data.values()

# 需要导入模块: from durus.persistent_dict import PersistentDict [as 别名]
# 或者: from durus.persistent_dict.PersistentDict import get [as 别名]
 def test_get(self):
     pd = PersistentDict((x, True) for x in range(10))
     assert pd.get(2) == True
     assert pd.get(-1) == None
     assert pd.get(-1, 5) == 5

# 需要导入模块: from durus.persistent_dict import PersistentDict [as 别名]
# 或者: from durus.persistent_dict.PersistentDict import get [as 别名]
class NetworkDevice(OwnedPersistent):
	"""NetworkDevice([name])
This object is a persistent store object that represents a networked device as
a collection of interfaces. It has a name that is used for string conversion.
	"""
	# the following (class-level attributes) become the default values for
	# various methods. Set an instance attribute of the same name to override
	# these values.
	user = None # default user to log in as
	password = None # default password for default user
	prompt = "# " # default CLI prompt for interactive sessions
	accessmethod = "ssh" # default. Possible are: ssh, console, serial, telnet, snmp
	initialaccessmethod = "console" # how to access for initial (before accessmethod is available) access
	console_server = (None, None) # host and TCP port used to connect to device serial console
	power_controller = (None, None) # APC host and outlet number used to control power
	monitor_port = (None, None) # may contain tuple of (device, interface) of an etherswitch to monitor
	domain = None # default DNS domain of the device
	nameservers = []	   # default DNS server list to be configured
	ntpserver = None	   # default NTP server to configure
	sysObjectID = None # The SNMP object identifier for a (sub)class of device.
	snmpRoCommunity = "public"	   # default RO SNMP community to use
	snmpRwCommunity = "private"    # default RW SNMP community to use
	admin_interface = "eth0" # interface on administrative network. This interface is "invisible" to device methods.
	data_interfaces = ["eth0"] # the "business" interfaces that are in use.

	def __init__(self, name):
		super(NetworkDevice, self).__init__()
		self.name = self.hostname = str(name)
		self.INTERFACEMAP = PersistentDict()
		self._interfaces = PersistentDict()
		self.data_interfaces = PersistentList()
		self.admin_interface = None
		self.initialize() # subclass interface

	# a non-persistent dictionary to cache transient attributes from a device
	def _get_cache(self):
		try:
			return self.__dict__["_cache_"]
		except KeyError:
			import dictlib
			c = dictlib.AttrDict()
			self.__dict__["_cache_"] = c
			return c
	_cache = property(_get_cache)

	def __repr__(self):
		return "%s(%r)" % (self.__class__.__name__, self.name)

	def __str__(self):
		return self.name # don't change this or you will break a lot of things 

	def initialize(self):
		pass

	def interface_alias(self, name, alias=None):
		"""sets (or removes) an alias name for an interface."""
		if alias is not None:
			self.INTERFACEMAP[str(alias)] = str(name)
		else:
			del self.INTERFACEMAP[str(name)]

	def set_hostname(self, name):
		"""Sets the hostname (and alias "name" attribute)."""
		self.name = self.hostname = str(name)

	def add_interface(self, devname, address=None, mask=None, hostname=None, linktype=BROADCAST):
		"""add_interface(devname, [address, [mask, [hostname, [linktype]]]])
Adds a new network interface to the device. Supply its interface name, and its
address.
		"""
		devname = self.INTERFACEMAP.get(devname, devname)
		if self._interfaces.has_key(devname):
			return self._interfaces[devname].update(address, mask, hostname, linktype)
		if not address:
			try:
				address=ipv4.IPv4(self.hostname)
			except:
				address = None
		if not hostname:
			if address:
				try:
					hostname = address.hostname
				except:
					hostname = "%s_%s" % (self.hostname, devname)
			else:
				hostname = "%s_%s" % (self.hostname, devname)
		intf = Interface(devname, address, mask, hostname, linktype)
		self._interfaces[devname] = intf
		intf.owner = self
		self._p_note_change()
		return intf

	def update_interface(self, devname, address=None, mask=None, hostname=None, linktype=BROADCAST):
		devname = self.INTERFACEMAP.get(devname, devname)
		return self._interfaces[devname].update(address, mask, hostname, linktype)

	def get_interface(self, devname):
		"""Return an Interface object from the index. The index value may be an integer or a name.  """
		devname = self.INTERFACEMAP.get(devname, devname)
		return self._interfaces[devname]
#.........这里部分代码省略.........

# 需要导入模块: from durus.persistent_dict import PersistentDict [as 别名]
# 或者: from durus.persistent_dict.PersistentDict import get [as 别名]
class IPAssignments(OwnedPersistent):
	def __init__(self, name, *args):
		super(IPAssignments, self).__init__()
		self.name = name
		self._store = PersistentDict()
		for arg in args:
			self.add(arg)

	def __contains__(self, address):
		if isinstance(address, str):
			address = ipv4.IPv4(address)
		for ip in self._store.iterkeys():
			if address == ip:
				return True
		return False

	def __str__(self):
		s = []
		for address, disp in self._store.items():
			s.append("%s is %s\n" % (address.cidr(), IF(disp, "used.", "free.")))
		s.sort()
		return "".join(s)

	def __repr__(self):
		return "%s(%r, ...)" % (self.__class__.__name__, self.name)

	def __iter__(self):
		return self._store.iteritems()

	def get(self, ip):
		if isinstance(ip, str):
			ip = ipv4.IPv4(ip)
		return ip, self._store.get(ip)

	def add(self, arg):
		if isinstance(arg, str):
			arg = ipv4.IPv4(arg)
		if isinstance(arg, ipv4.IPRange):
			for ip in arg:
				self._store[ip] = False
		elif isinstance(arg, ipv4.IPv4):
			for ip in arg[1:-1]:
				self._store[ip] = False
		else:
			raise ValueError, "must be IP address or Range."

	# IPv4 used as a VLSM range here
	def add_net(self, ipnet):
		if isinstance(ipnet, str):
			ipnet = ipv4.IPv4(ipnet)
		if isinstance(ipnet, ipv4.IPv4):
			for ip in ipnet[1:-1]:
				self._store[ip] = False
		else:
			raise ValueError, "must add IPv4 network"
	add_network = add_net
	
	def add_range(self, addr1, addr2):
		rng = ipv4.IPRange(addr1, addr2)
		for ip in rng:
			self._store[ip] = False

	def remove(self, arg):
		if isinstance(arg, str):
			arg = ipv4.IPv4(arg)
		if isinstance(arg, ipv4.IPRange):
			for ip in arg:
				try:
					del self._store[ip]
				except KeyError:
					pass
		elif isinstance(arg, ipv4.IPv4):
			for ip in arg[1:-1]:
				try:
					del self._store[ip]
				except KeyError:
					pass
		else:
			raise ValueError, "must be IP address or Range."
	
	# removes the given range of IP. Useful for making "holes"
	def remove_range(self, addr1, addr2):
		rng = ipv4.IPRange(addr1, addr2)
		for ip in rng:
			try:
				del self._store[ip]
			except KeyError:
				pass
	
	def remove_net(self, ipnet):
		if isinstance(ipnet, str):
			ipnet = ipv4.IPv4(ipnet)
		if isinstance(ipnet, ipv4.IPv4):
			for ip in ipnet[1:-1]:
				try:
					del self._store[ip]
				except KeyError:
					pass
		else:
			raise ValueError, "must add IPv4 network"
#.........这里部分代码省略.........