def _checkend(r):
x, rest = r
if rest != '':
- raise SyntaxError, 'junk at end of string'
+ raise SyntaxError('junk at end of string')
return x
## Some pretty-printing utilities.
pp.end_group(ind, ')')
def check(me, sz): return me.min <= sz <= me.max and sz%me.mod == 0
def best(me, sz):
- if sz < me.min: raise ValueError, 'key too small'
+ if sz < me.min: raise ValueError('key too small')
elif sz > me.max: return me.max
else: return sz - sz%me.mod
def pad(me, sz):
- if sz > me.max: raise ValueError, 'key too large'
+ if sz > me.max: raise ValueError('key too large')
elif sz < me.min: return me.min
else: sz += me.mod - 1; return sz - sz%me.mod
_augment(KeySZRange, _tmp)
found = -1
for i in me.set:
if found < i <= sz: found = i
- if found < 0: raise ValueError, 'key too small'
+ if found < 0: raise ValueError('key too small')
return found
def pad(me, sz):
found = -1
for i in me.set:
if sz <= i and (found == -1 or i < found): found = i
- if found < 0: raise ValueError, 'key too large'
+ if found < 0: raise ValueError('key too large')
return found
_augment(KeySZSet, _tmp)
class _BasePub (object):
def __init__(me, pub, *args, **kw):
- if not me._PUBSZ.check(len(pub)): raise ValueError, 'bad public key'
+ if not me._PUBSZ.check(len(pub)): raise ValueError('bad public key')
super(_BasePub, me).__init__(*args, **kw)
me.pub = pub
def __repr__(me): return '%s(pub = %r)' % (_clsname(me), me.pub)
class _BasePriv (object):
def __init__(me, priv, pub = None, *args, **kw):
- if not me._KEYSZ.check(len(priv)): raise ValueError, 'bad private key'
+ if not me._KEYSZ.check(len(priv)): raise ValueError('bad private key')
if pub is None: pub = me._pubkey(priv)
super(_BasePriv, me).__init__(pub = pub, *args, **kw)
me.priv = priv
me.add = add
def _stepfn(me, step):
if step <= 0:
- raise ValueError, 'step must be positive'
+ raise ValueError('step must be positive')
if step <= MPW_MAX:
return lambda f: f.step(step)
j = PrimeFilter(step)
`_open' method, which is invoked in the usual case.
"""
super(StorageBackend, me).__init__(*args, **kw)
- if me.NAME is None: raise ValueError, 'abstract class'
+ if me.NAME is None: raise ValueError('abstract class')
if _magic is not None: _magic(me)
- elif file is None: raise ValueError, 'missing file parameter'
+ elif file is None: raise ValueError('missing file parameter')
else: me._open(file, writep)
me._writep = writep
me._livep = True
def _check_live(me):
"""Raise an error if the receiver has been closed."""
- if not me._livep: raise ValueError, 'database is closed'
+ if not me._livep: raise ValueError('database is closed')
def _check_write(me):
"""Raise an error if the receiver is not open for writing."""
me._check_live()
- if not me._writep: raise ValueError, 'database is read-only'
+ if not me._writep: raise ValueError('database is read-only')
def _check_meta_name(me, name):
"""
password storage.
"""
if name.startswith('$'):
- raise ValueError, "invalid metadata key `%s'" % name
+ raise ValueError("invalid metadata key `%s'" % name)
## Context protocol.
me._check_meta_name(name)
me._check_live()
value = me._get_meta(name, default)
- if value is StorageBackend.FAIL: raise KeyError, name
+ if value is StorageBackend.FAIL: raise KeyError(name)
return value
def put_meta(me, name, value):
def _open(me, file, writep):
try: me._db = _G.open(file, writep and 'w' or 'r')
- except _G.error, e: raise StorageBackendRefusal, e
+ except _G.error, e: raise StorageBackendRefusal(e)
def _create(me, file):
me._db = _G.open(file, 'n', 0600)
"SELECT value FROM meta WHERE name = '$version'",
"version check")
except (_Q.DatabaseError, _Q.OperationalError), e:
- raise StorageBackendRefusal, e
- if ver is None: raise ValueError, 'database broken (missing $version)'
+ raise StorageBackendRefusal(e)
+ if ver is None: raise ValueError('database broken (missing $version)')
elif ver < me.VERSION: me._upgrade(ver)
- elif ver > me.VERSION:
- raise ValueError, 'unknown database schema version (%d > %d)' % \
- (ver, me.VERSION)
+ elif ver > me.VERSION: raise ValueError \
+ ('unknown database schema version (%d > %d)' % (ver, me.VERSION))
def _create(me, file):
fd = _OS.open(file, _OS.O_WRONLY | _OS.O_CREAT | _OS.O_EXCL, 0600)
else: val, = row
try: row = next(c)
except StopIteration: pass
- else: raise ValueError, 'multiple matching records for %s' % what
+ else: raise ValueError('multiple matching records for %s' % what)
return val
def _query_scalar(me, query, what, default = None, args = []):
def _del_meta(me, name):
c = me._db.cursor()
c.execute("DELETE FROM meta WHERE name = ?", [name])
- if not c.rowcount: raise KeyError, name
+ if not c.rowcount: raise KeyError(name)
def _iter_meta(me):
c = me._db.cursor()
pld = me._query_scalar("SELECT payload FROM passwd WHERE label = ?",
"password", default = None,
args = [buffer(label)])
- if pld is None: raise KeyError, label
+ if pld is None: raise KeyError(label)
return str(pld)
def _put_passwd(me, label, payload):
def _del_passwd(me, label):
c = me._db.cursor()
c.execute("DELETE FROM passwd WHERE label = ?", [label])
- if not c.rowcount: raise KeyError, label
+ if not c.rowcount: raise KeyError(label)
def _iter_passwds(me):
c = me._db.cursor()
try:
f = open(me._pwfile(label), 'rb')
except (OSError, IOError), e:
- if e.errno == _E.ENOENT: raise KeyError, label
+ if e.errno == _E.ENOENT: raise KeyError(label)
else: raise
with f: return f.read()
def _put_passwd(me, label, payload):
try:
_OS.remove(me._pwfile(label))
except (OSError, IOError), e:
- if e.errno == _E.ENOENT: raise KeyError, label
+ if e.errno == _E.ENOENT: raise KeyError(label)
else: raise
def _iter_passwds(me):
pw = _OS.path.join(me._dir, 'pw')
raise
me.ck = b.getblk16()
me.mk = b.getblk16()
- if not b.endp: raise ValueError, 'trailing junk'
+ if not b.endp: raise ValueError('trailing junk')
## Set the key, and stash it and the tag-hashing secret.
me.k = Crypto(c, h, m, me.ck, me.mk)
def __getitem__(me, key):
"""Return the password for the given KEY."""
try: return me.unpack(me.db.get_passwd(me.keyxform(key)))[1]
- except KeyError: raise KeyError, key
+ except KeyError: raise KeyError(key)
def __setitem__(me, key, value):
"""Associate the password VALUE with the KEY."""
def __delitem__(me, key):
"""Forget all about the KEY."""
try: me.db.del_passwd(me.keyxform(key))
- except KeyError: raise KeyError, key
+ except KeyError: raise KeyError(key)
def __iter__(me):
"""Iterate over the known password tags."""
~mdw / catacomb-python / commitdiff