This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2930

thirdparty: port zope.interface to relative imports
ClosedPublic

Authored by indygreg on Mar 22 2018, 12:09 AM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG68ee61822182: thirdparty: port zope.interface to relative imports
Summary

By using relative imports, we're guaranteed to get modules
vendored with Mercurial rather than other random modules
that might be in sys.path.

My editor strips trailing whitespace on save. So some minor
source code cleanup was also performed as part of this commit.

  1. no-check-commit because some modified lines have double newlines

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

indygreg created this revision.Mar 22 2018, 12:09 AM
durin42 accepted this revision.Mar 29 2018, 1:02 PM
This revision is now accepted and ready to land.Mar 29 2018, 1:02 PM
Closed by commit rHG68ee61822182: thirdparty: port zope.interface to relative imports (authored by indygreg). · Explain WhyMar 30 2018, 2:13 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 7397

mercurial/thirdparty/zope/interface/__init__.py

o `exceptions` has the interface-defined exceptions o `exceptions` has the interface-defined exceptions
o `interfaces` contains a list of all public interfaces for this package. o `interfaces` contains a list of all public interfaces for this package.
o `verify` has utilities for verifying implementations of interfaces. o `verify` has utilities for verifying implementations of interfaces.
See the module doc strings for more information. See the module doc strings for more information.
""" """
from __future__ import absolute_import
__docformat__ = 'restructuredtext' __docformat__ = 'restructuredtext'
from zope.interface.interface import Interface from .interface import Interface
from zope.interface.interface import _wire from .interface import _wire
# Need to actually get the interface elements to implement the right interfaces # Need to actually get the interface elements to implement the right interfaces
_wire() _wire()
del _wire del _wire
from zope.interface.declarations import Declaration from .declarations import Declaration
from zope.interface.declarations import alsoProvides from .declarations import alsoProvides
from zope.interface.declarations import classImplements from .declarations import classImplements
from zope.interface.declarations import classImplementsOnly from .declarations import classImplementsOnly
from zope.interface.declarations import classProvides from .declarations import classProvides
from zope.interface.declarations import directlyProvidedBy from .declarations import directlyProvidedBy
from zope.interface.declarations import directlyProvides from .declarations import directlyProvides
from zope.interface.declarations import implementedBy from .declarations import implementedBy
from zope.interface.declarations import implementer from .declarations import implementer
from zope.interface.declarations import implementer_only from .declarations import implementer_only
from zope.interface.declarations import implements from .declarations import implements
from zope.interface.declarations import implementsOnly from .declarations import implementsOnly
from zope.interface.declarations import moduleProvides from .declarations import moduleProvides
from zope.interface.declarations import named from .declarations import named
from zope.interface.declarations import noLongerProvides from .declarations import noLongerProvides
from zope.interface.declarations import providedBy from .declarations import providedBy
from zope.interface.declarations import provider from .declarations import provider
from zope.interface.exceptions import Invalid from .exceptions import Invalid
from zope.interface.interface import Attribute from .interface import Attribute
from zope.interface.interface import invariant from .interface import invariant
from zope.interface.interface import taggedValue from .interface import taggedValue
# The following are to make spec pickles cleaner # The following are to make spec pickles cleaner
from zope.interface.declarations import Provides from .declarations import Provides
from zope.interface.interfaces import IInterfaceDeclaration from .interfaces import IInterfaceDeclaration
moduleProvides(IInterfaceDeclaration) moduleProvides(IInterfaceDeclaration)
__all__ = ('Interface', 'Attribute') + tuple(IInterfaceDeclaration) __all__ = ('Interface', 'Attribute') + tuple(IInterfaceDeclaration)

mercurial/thirdparty/zope/interface/_compat.py

############################################################################## ##############################################################################
# #
# Copyright (c) 2006 Zope Foundation and Contributors. # Copyright (c) 2006 Zope Foundation and Contributors.
# All Rights Reserved. # All Rights Reserved.
# #
# This software is subject to the provisions of the Zope Public License, # This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. # Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE. # FOR A PARTICULAR PURPOSE.
# #
############################################################################## ##############################################################################
"""Basic components support """Basic components support
""" """
from __future__ import absolute_import
import sys import sys
import types import types
if sys.version_info[0] < 3: if sys.version_info[0] < 3:
def _normalize_name(name): def _normalize_name(name):
if isinstance(name, basestring): if isinstance(name, basestring):
return unicode(name) return unicode(name)

mercurial/thirdparty/zope/interface/_flatten.py

# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE. # FOR A PARTICULAR PURPOSE.
# #
############################################################################## ##############################################################################
"""Adapter-style interface registry """Adapter-style interface registry
See Adapter class. See Adapter class.
""" """
from zope.interface import Declaration
from __future__ import absolute_import
from .interface import Declaration
def _flatten(implements, include_None=0): def _flatten(implements, include_None=0):
try: try:
r = implements.flattened() r = implements.flattened()
except AttributeError: except AttributeError:
if implements is None: if implements is None:
r=() r=()

mercurial/thirdparty/zope/interface/_zope_interface_coptimizations.c

static int imported_declarations = 0; static int imported_declarations = 0;
static int static int
import_declarations(void) import_declarations(void)
{ {
PyObject *declarations, *i; PyObject *declarations, *i;
declarations = PyImport_ImportModule("zope.interface.declarations"); declarations = PyImport_ImportModule(
"mercurial.thirdparty.zope.interface.declarations");
if (declarations == NULL) if (declarations == NULL)
return -1; return -1;
BuiltinImplementationSpecifications = PyObject_GetAttrString( BuiltinImplementationSpecifications = PyObject_GetAttrString(
declarations, "BuiltinImplementationSpecifications"); declarations, "BuiltinImplementationSpecifications");
if (BuiltinImplementationSpecifications == NULL) if (BuiltinImplementationSpecifications == NULL)
return -1; return -1;
Py_CLEAR(self->_verify_ro); Py_CLEAR(self->_verify_ro);
return 0; return 0;
} }
static void static void
verifying_dealloc(verify *self) verifying_dealloc(verify *self)
{ {
PyObject_GC_UnTrack((PyObject *)self); PyObject_GC_UnTrack((PyObject *)self);
verifying_clear(self); verifying_clear(self);
Py_TYPE(self)->tp_free((PyObject*)self); Py_TYPE(self)->tp_free((PyObject*)self);
} }
/* /*
def changed(self, originally_changed): def changed(self, originally_changed):
super(VerifyingBasePy, self).changed(originally_changed) super(VerifyingBasePy, self).changed(originally_changed)
self._verify_ro = self._registry.ro[1:] self._verify_ro = self._registry.ro[1:]

mercurial/thirdparty/zope/interface/adapter.py

############################################################################## ##############################################################################
# #
# Copyright (c) 2004 Zope Foundation and Contributors. # Copyright (c) 2004 Zope Foundation and Contributors.
# All Rights Reserved. # All Rights Reserved.
# #
# This software is subject to the provisions of the Zope Public License, # This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. # Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE. # FOR A PARTICULAR PURPOSE.
# #
############################################################################## ##############################################################################
"""Adapter management """Adapter management
""" """
from __future__ import absolute_import
import weakref import weakref
from zope.interface import implementer from . import implementer
from zope.interface import providedBy from . import providedBy
from zope.interface import Interface from . import Interface
from zope.interface import ro from . import ro
from zope.interface.interfaces import IAdapterRegistry from .interfaces import IAdapterRegistry
from zope.interface._compat import _normalize_name from ._compat import _normalize_name
from zope.interface._compat import STRING_TYPES from ._compat import STRING_TYPES
_BLANK = u'' _BLANK = u''
class BaseAdapterRegistry(object): class BaseAdapterRegistry(object):
# List of methods copied from lookup sub-objects: # List of methods copied from lookup sub-objects:
_delegated = ('lookup', 'queryMultiAdapter', 'lookup1', 'queryAdapter', _delegated = ('lookup', 'queryMultiAdapter', 'lookup1', 'queryAdapter',
'adapter_hook', 'lookupAll', 'names', 'adapter_hook', 'lookupAll', 'names',
result = self._uncached_subscriptions(required, provided) result = self._uncached_subscriptions(required, provided)
cache[required] = result cache[required] = result
return result return result
LookupBasePy = LookupBaseFallback # BBB LookupBasePy = LookupBaseFallback # BBB
try: try:
from zope.interface._zope_interface_coptimizations import LookupBase from ._zope_interface_coptimizations import LookupBase
except ImportError: except ImportError:
LookupBase = LookupBaseFallback LookupBase = LookupBaseFallback
class VerifyingBaseFallback(LookupBaseFallback): class VerifyingBaseFallback(LookupBaseFallback):
# Mixin for lookups against registries which "chain" upwards, and # Mixin for lookups against registries which "chain" upwards, and
# whose lookups invalidate their own caches whenever a parent registry # whose lookups invalidate their own caches whenever a parent registry
# bumps its own '_generation' counter. E.g., used by # bumps its own '_generation' counter. E.g., used by
def subscriptions(self, required, provided): def subscriptions(self, required, provided):
self._verify() self._verify()
return LookupBaseFallback.subscriptions(self, required, provided) return LookupBaseFallback.subscriptions(self, required, provided)
VerifyingBasePy = VerifyingBaseFallback #BBB VerifyingBasePy = VerifyingBaseFallback #BBB
try: try:
from zope.interface._zope_interface_coptimizations import VerifyingBase from ._zope_interface_coptimizations import VerifyingBase
except ImportError: except ImportError:
VerifyingBase = VerifyingBaseFallback VerifyingBase = VerifyingBaseFallback
class AdapterLookupBase(object): class AdapterLookupBase(object):
def __init__(self, registry): def __init__(self, registry):
self._registry = registry self._registry = registry

mercurial/thirdparty/zope/interface/advice.py

can be kept in sync. can be kept in sync.
PEAK is a Python application framework that interoperates with (but does PEAK is a Python application framework that interoperates with (but does
not require) Zope 3 and Twisted. It provides tools for manipulating UML not require) Zope 3 and Twisted. It provides tools for manipulating UML
models, object-relational persistence, aspect-oriented programming, and more. models, object-relational persistence, aspect-oriented programming, and more.
Visit the PEAK home page at http://peak.telecommunity.com for more information. Visit the PEAK home page at http://peak.telecommunity.com for more information.
""" """
from __future__ import absolute_import
from types import FunctionType from types import FunctionType
try: try:
from types import ClassType from types import ClassType
except ImportError: except ImportError:
__python3 = True __python3 = True
else: else:
__python3 = False __python3 = False

mercurial/thirdparty/zope/interface/common/idatetime.py

############################################################################## ##############################################################################
# Copyright (c) 2002 Zope Foundation and Contributors. # Copyright (c) 2002 Zope Foundation and Contributors.
# All Rights Reserved. # All Rights Reserved.
# #
# This software is subject to the provisions of the Zope Public License, # This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. # Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE. # FOR A PARTICULAR PURPOSE.
############################################################################## ##############################################################################
"""Datetime interfaces. """Datetime interfaces.
This module is called idatetime because if it were called datetime the import This module is called idatetime because if it were called datetime the import
of the real datetime would fail. of the real datetime would fail.
""" """
from zope.interface import Interface, Attribute from __future__ import absolute_import
from zope.interface import classImplements
from .. import Interface, Attribute
from .. import classImplements
from datetime import timedelta, date, datetime, time, tzinfo from datetime import timedelta, date, datetime, time, tzinfo
class ITimeDeltaClass(Interface): class ITimeDeltaClass(Interface):
"""This is the timedelta class interface.""" """This is the timedelta class interface."""
min = Attribute("The most negative timedelta object") min = Attribute("The most negative timedelta object")
day = Attribute( day = Attribute(
"Between 1 and the number of days in the given month of the given year.") "Between 1 and the number of days in the given month of the given year.")
def replace(year, month, day): def replace(year, month, day):
"""Return a date with the same value. """Return a date with the same value.
Except for those members given new values by whichever keyword Except for those members given new values by whichever keyword
arguments are specified. For example, if d == date(2002, 12, 31), then arguments are specified. For example, if d == date(2002, 12, 31), then
d.replace(day=26) == date(2000, 12, 26). d.replace(day=26) == date(2000, 12, 26).
""" """
def timetuple(): def timetuple():
"""Return a 9-element tuple of the form returned by time.localtime(). """Return a 9-element tuple of the form returned by time.localtime().
The hours, minutes and seconds are 0, and the DST flag is -1. The hours, minutes and seconds are 0, and the DST flag is -1.
d.timetuple() is equivalent to d.timetuple() is equivalent to
(d.year, d.month, d.day, 0, 0, 0, d.weekday(), d.toordinal() - (d.year, d.month, d.day, 0, 0, 0, d.weekday(), d.toordinal() -
See also today(), utcnow(). See also today(), utcnow().
""" """
def utcnow(): def utcnow():
"""Return the current UTC date and time, with tzinfo None. """Return the current UTC date and time, with tzinfo None.
This is like now(), but returns the current UTC date and time, as a This is like now(), but returns the current UTC date and time, as a
naive datetime object. naive datetime object.
See also now(). See also now().
""" """
def fromtimestamp(timestamp, tz=None): def fromtimestamp(timestamp, tz=None):
"""Return the local date and time corresponding to the POSIX timestamp. """Return the local date and time corresponding to the POSIX timestamp.
Same as is returned by time.time(). If optional argument tz is None or Same as is returned by time.time(). If optional argument tz is None or
will usually have the same date and time members as dt - dt.utcoffset(). will usually have the same date and time members as dt - dt.utcoffset().
The discussion of class tzinfo explains the cases at Daylight Saving The discussion of class tzinfo explains the cases at Daylight Saving
Time transition boundaries where this cannot be achieved (an issue only Time transition boundaries where this cannot be achieved (an issue only
if tz models both standard and daylight time). if tz models both standard and daylight time).
If you merely want to attach a time zone object tz to a datetime dt If you merely want to attach a time zone object tz to a datetime dt
without adjustment of date and time members, use dt.replace(tzinfo=tz). without adjustment of date and time members, use dt.replace(tzinfo=tz).
If you merely want to remove the time zone object from an aware If you merely want to remove the time zone object from an aware
datetime dt without conversion of date and time members, use datetime dt without conversion of date and time members, use
dt.replace(tzinfo=None). dt.replace(tzinfo=None).
Note that the default tzinfo.fromutc() method can be overridden in a Note that the default tzinfo.fromutc() method can be overridden in a
tzinfo subclass to effect the result returned by astimezone(). tzinfo subclass to effect the result returned by astimezone().
""" """
def utcoffset(): def utcoffset():
"""Return the timezone offset in minutes east of UTC (negative west of """Return the timezone offset in minutes east of UTC (negative west of

mercurial/thirdparty/zope/interface/common/interfaces.py

############################################################################## ##############################################################################
# #
# Copyright (c) 2003 Zope Foundation and Contributors. # Copyright (c) 2003 Zope Foundation and Contributors.
# All Rights Reserved. # All Rights Reserved.
# #
# This software is subject to the provisions of the Zope Public License, # This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. # Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE. # FOR A PARTICULAR PURPOSE.
# #
############################################################################## ##############################################################################
"""Interfaces for standard python exceptions """Interfaces for standard python exceptions
""" """
from zope.interface import Interface
from zope.interface import classImplements from __future__ import absolute_import
from .. import Interface
from .. import classImplements
class IException(Interface): pass class IException(Interface): pass
class IStandardError(IException): pass class IStandardError(IException): pass
class IWarning(IException): pass class IWarning(IException): pass
class ISyntaxError(IStandardError): pass class ISyntaxError(IStandardError): pass
class ILookupError(IStandardError): pass class ILookupError(IStandardError): pass
class IValueError(IStandardError): pass class IValueError(IStandardError): pass
class IRuntimeError(IStandardError): pass class IRuntimeError(IStandardError): pass

mercurial/thirdparty/zope/interface/common/mapping.py

############################################################################## ##############################################################################
# #
# Copyright (c) 2001, 2002 Zope Foundation and Contributors. # Copyright (c) 2001, 2002 Zope Foundation and Contributors.
# All Rights Reserved. # All Rights Reserved.
# #
# This software is subject to the provisions of the Zope Public License, # This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. # Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE. # FOR A PARTICULAR PURPOSE.
# #
############################################################################## ##############################################################################
"""Mapping Interfaces """Mapping Interfaces
""" """
from zope.interface import Interface
from __future__ import absolute_import
from .. import Interface
class IItemMapping(Interface): class IItemMapping(Interface):
"""Simplest readable mapping object """Simplest readable mapping object
""" """
def __getitem__(key): def __getitem__(key):
"""Get a value for a key """Get a value for a key
""" """
def __contains__(key): def __contains__(key):
"""Tell if a key exists in the mapping.""" """Tell if a key exists in the mapping."""
class IWriteMapping(Interface): class IWriteMapping(Interface):
"""Mapping methods for changing data""" """Mapping methods for changing data"""
def __delitem__(key): def __delitem__(key):
"""Delete a value from the mapping using the key.""" """Delete a value from the mapping using the key."""
def __setitem__(key, value): def __setitem__(key, value):
"""Set a new item in the mapping.""" """Set a new item in the mapping."""
class IEnumerableMapping(IReadMapping): class IEnumerableMapping(IReadMapping):
"""Mapping objects whose items can be enumerated. """Mapping objects whose items can be enumerated.
""" """
def keys(): def keys():
"""Return the keys of the mapping object. """Return the keys of the mapping object.
""" """
def itervalues(): def itervalues():
"iterate over values" "iterate over values"
def iteritems(): def iteritems():
"iterate over items" "iterate over items"
class IClonableMapping(Interface): class IClonableMapping(Interface):
def copy(): def copy():
"return copy of dict" "return copy of dict"
class IExtendedReadMapping(IIterableMapping): class IExtendedReadMapping(IIterableMapping):
def has_key(key): def has_key(key):
"""Tell if a key exists in the mapping; equivalent to __contains__""" """Tell if a key exists in the mapping; equivalent to __contains__"""
class IExtendedWriteMapping(IWriteMapping): class IExtendedWriteMapping(IWriteMapping):
def clear(): def clear():
"delete all items" "delete all items"
def update(d): def update(d):
" Update D from E: for k in E.keys(): D[k] = E[k]" " Update D from E: for k in E.keys(): D[k] = E[k]"
def setdefault(key, default=None): def setdefault(key, default=None):
"D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D" "D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D"
def pop(k, *args): def pop(k, *args):
"""remove specified key and return the corresponding value """remove specified key and return the corresponding value
*args may contain a single default value, or may not be supplied. *args may contain a single default value, or may not be supplied.
If key is not found, default is returned if given, otherwise If key is not found, default is returned if given, otherwise
KeyError is raised""" KeyError is raised"""
def popitem(): def popitem():
"""remove and return some (key, value) pair as a """remove and return some (key, value) pair as a
2-tuple; but raise KeyError if mapping is empty""" 2-tuple; but raise KeyError if mapping is empty"""
class IFullMapping( class IFullMapping(
IExtendedReadMapping, IExtendedWriteMapping, IClonableMapping, IMapping): IExtendedReadMapping, IExtendedWriteMapping, IClonableMapping, IMapping):
''' Full mapping interface ''' # IMapping included so tests for IMapping ''' Full mapping interface ''' # IMapping included so tests for IMapping
# succeed with IFullMapping # succeed with IFullMapping

mercurial/thirdparty/zope/interface/common/sequence.py

############################################################################## ##############################################################################
# #
# Copyright (c) 2001, 2002 Zope Foundation and Contributors. # Copyright (c) 2001, 2002 Zope Foundation and Contributors.
# All Rights Reserved. # All Rights Reserved.
# #
# This software is subject to the provisions of the Zope Public License, # This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. # Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE. # FOR A PARTICULAR PURPOSE.
# #
############################################################################## ##############################################################################
"""Sequence Interfaces """Sequence Interfaces
""" """
from __future__ import absolute_import
__docformat__ = 'restructuredtext' __docformat__ = 'restructuredtext'
from zope.interface import Interface from .. import Interface
class IMinimalSequence(Interface): class IMinimalSequence(Interface):
"""Most basic sequence interface. """Most basic sequence interface.
All sequences are iterable. This requires at least one of the All sequences are iterable. This requires at least one of the
following: following:
- a `__getitem__()` method that takes a single argument; interger - a `__getitem__()` method that takes a single argument; interger

mercurial/thirdparty/zope/interface/declarations.py

class implements (that instances of the class provides). class implements (that instances of the class provides).
Implements specifications support inheriting interfaces. Implements specifications support inheriting interfaces.
- ProvidesDeclarations are used to express interfaces directly - ProvidesDeclarations are used to express interfaces directly
provided by objects. provided by objects.
""" """
from __future__ import absolute_import
__docformat__ = 'restructuredtext' __docformat__ = 'restructuredtext'
import sys import sys
from types import FunctionType from types import FunctionType
from types import MethodType from types import MethodType
from types import ModuleType from types import ModuleType
import weakref import weakref
from zope.interface.advice import addClassAdvisor from .advice import addClassAdvisor
from zope.interface.interface import InterfaceClass from .interface import InterfaceClass
from zope.interface.interface import SpecificationBase from .interface import SpecificationBase
from zope.interface.interface import Specification from .interface import Specification
from zope.interface._compat import CLASS_TYPES as DescriptorAwareMetaClasses from ._compat import CLASS_TYPES as DescriptorAwareMetaClasses
from zope.interface._compat import PYTHON3 from ._compat import PYTHON3
# Registry of class-implementation specifications # Registry of class-implementation specifications
BuiltinImplementationSpecifications = {} BuiltinImplementationSpecifications = {}
_ADVICE_ERROR = ('Class advice impossible in Python3. ' _ADVICE_ERROR = ('Class advice impossible in Python3. '
'Use the @%s class decorator instead.') 'Use the @%s class decorator instead.')
_ADVICE_WARNING = ('The %s API is deprecated, and will not work in Python3 ' _ADVICE_WARNING = ('The %s API is deprecated, and will not work in Python3 '
raise AttributeError('__provides__') raise AttributeError('__provides__')
ClassProvidesBasePy = ClassProvidesBaseFallback # BBB ClassProvidesBasePy = ClassProvidesBaseFallback # BBB
ClassProvidesBase = ClassProvidesBaseFallback ClassProvidesBase = ClassProvidesBaseFallback
# Try to get C base: # Try to get C base:
try: try:
import zope.interface._zope_interface_coptimizations from . import _zope_interface_coptimizations
except ImportError: except ImportError:
pass pass
else: else:
from zope.interface._zope_interface_coptimizations import ClassProvidesBase from ._zope_interface_coptimizations import ClassProvidesBase
class ClassProvides(Declaration, ClassProvidesBase): class ClassProvides(Declaration, ClassProvidesBase):
"""Special descriptor for class __provides__ """Special descriptor for class __provides__
The descriptor caches the implementedBy info, so that The descriptor caches the implementedBy info, so that
we can get declarations for objects without instance-specific we can get declarations for objects without instance-specific
interfaces a bit quicker. interfaces a bit quicker.
for v in sequence: for v in sequence:
_normalizeargs(v, output) _normalizeargs(v, output)
return output return output
_empty = Declaration() _empty = Declaration()
try: try:
import zope.interface._zope_interface_coptimizations from . import _zope_interface_coptimizations
except ImportError: except ImportError:
pass pass
else: else:
from zope.interface._zope_interface_coptimizations import implementedBy from ._zope_interface_coptimizations import implementedBy
from zope.interface._zope_interface_coptimizations import providedBy from ._zope_interface_coptimizations import providedBy
from zope.interface._zope_interface_coptimizations import ( from ._zope_interface_coptimizations import (
getObjectSpecification) getObjectSpecification)
from zope.interface._zope_interface_coptimizations import ( from ._zope_interface_coptimizations import (
ObjectSpecificationDescriptor) ObjectSpecificationDescriptor)
objectSpecificationDescriptor = ObjectSpecificationDescriptor() objectSpecificationDescriptor = ObjectSpecificationDescriptor()

mercurial/thirdparty/zope/interface/document.py

# FOR A PARTICULAR PURPOSE. # FOR A PARTICULAR PURPOSE.
# #
############################################################################## ##############################################################################
""" Pretty-Print an Interface object as structured text (Yum) """ Pretty-Print an Interface object as structured text (Yum)
This module provides a function, asStructuredText, for rendering an This module provides a function, asStructuredText, for rendering an
interface as structured text. interface as structured text.
""" """
import zope.interface
from __future__ import absolute_import
from . import Interface
def asStructuredText(I, munge=0, rst=False): def asStructuredText(I, munge=0, rst=False):
""" Output structured text format. Note, this will whack any existing """ Output structured text format. Note, this will whack any existing
'structured' format of the text. 'structured' format of the text.
If `rst=True`, then the output will quote all code as inline literals in If `rst=True`, then the output will quote all code as inline literals in
accordance with 'reStructuredText' markup principles. accordance with 'reStructuredText' markup principles.
""" """
if rst: if rst:
inline_literal = lambda s: "``%s``" % (s,) inline_literal = lambda s: "``%s``" % (s,)
else: else:
inline_literal = lambda s: s inline_literal = lambda s: s
r = [inline_literal(I.getName())] r = [inline_literal(I.getName())]
outp = r.append outp = r.append
level = 1 level = 1
if I.getDoc(): if I.getDoc():
outp(_justify_and_indent(_trim_doc_string(I.getDoc()), level)) outp(_justify_and_indent(_trim_doc_string(I.getDoc()), level))
bases = [base bases = [base
for base in I.__bases__ for base in I.__bases__
if base is not zope.interface.Interface if base is not Interface
] ]
if bases: if bases:
outp(_justify_and_indent("This interface extends:", level, munge)) outp(_justify_and_indent("This interface extends:", level, munge))
level += 1 level += 1
for b in bases: for b in bases:
item = "o %s" % inline_literal(b.getName()) item = "o %s" % inline_literal(b.getName())
outp(_justify_and_indent(_trim_doc_string(item), level, munge)) outp(_justify_and_indent(_trim_doc_string(item), level, munge))
level -= 1 level -= 1

mercurial/thirdparty/zope/interface/exceptions.py

############################################################################## ##############################################################################
# #
# Copyright (c) 2002 Zope Foundation and Contributors. # Copyright (c) 2002 Zope Foundation and Contributors.
# All Rights Reserved. # All Rights Reserved.
# #
# This software is subject to the provisions of the Zope Public License, # This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. # Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE. # FOR A PARTICULAR PURPOSE.
# #
############################################################################## ##############################################################################
"""Interface-specific exceptions """Interface-specific exceptions
""" """
from __future__ import absolute_import
class Invalid(Exception): class Invalid(Exception):
"""A specification is violated """A specification is violated
""" """
class DoesNotImplement(Invalid): class DoesNotImplement(Invalid):
""" This object does not implement """ """ This object does not implement """
def __init__(self, interface): def __init__(self, interface):
self.interface = interface self.interface = interface

mercurial/thirdparty/zope/interface/interface.py

############################################################################## ##############################################################################
# #
# Copyright (c) 2001, 2002 Zope Foundation and Contributors. # Copyright (c) 2001, 2002 Zope Foundation and Contributors.
# All Rights Reserved. # All Rights Reserved.
# #
# This software is subject to the provisions of the Zope Public License, # This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. # Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE. # FOR A PARTICULAR PURPOSE.
# #
############################################################################## ##############################################################################
"""Interface object implementation """Interface object implementation
""" """
from __future__ import generators from __future__ import absolute_import, generators
import sys import sys
from types import MethodType from types import MethodType
from types import FunctionType from types import FunctionType
import warnings import warnings
import weakref import weakref
from zope.interface.exceptions import Invalid from .exceptions import Invalid
from zope.interface.ro import ro from .ro import ro
CO_VARARGS = 4 CO_VARARGS = 4
CO_VARKEYWORDS = 8 CO_VARKEYWORDS = 8
TAGGED_DATA = '__interface_tagged_values__' TAGGED_DATA = '__interface_tagged_values__'
_decorator_non_return = object() _decorator_non_return = object()
"""Is the interface the same as or extend the given interface """Is the interface the same as or extend the given interface
""" """
return interface in self._implied return interface in self._implied
__call__ = isOrExtends __call__ = isOrExtends
SpecificationBase = SpecificationBasePy SpecificationBase = SpecificationBasePy
try: try:
from zope.interface._zope_interface_coptimizations import SpecificationBase from ._zope_interface_coptimizations import SpecificationBase
except ImportError: except ImportError:
pass pass
_marker = object() _marker = object()
class InterfaceBasePy(object): class InterfaceBasePy(object):
"""Base class that wants to be replaced with a C base :) """Base class that wants to be replaced with a C base :)
""" """
for hook in adapter_hooks: for hook in adapter_hooks:
adapter = hook(self, obj) adapter = hook(self, obj)
if adapter is not None: if adapter is not None:
return adapter return adapter
InterfaceBase = InterfaceBasePy InterfaceBase = InterfaceBasePy
try: try:
from zope.interface._zope_interface_coptimizations import InterfaceBase from ._zope_interface_coptimizations import InterfaceBase
except ImportError: except ImportError:
pass pass
adapter_hooks = [] adapter_hooks = []
try: try:
from zope.interface._zope_interface_coptimizations import adapter_hooks from ._zope_interface_coptimizations import adapter_hooks
except ImportError: except ImportError:
pass pass
class Specification(SpecificationBase): class Specification(SpecificationBase):
"""Specifications """Specifications
An interface specification is used to track interface declarations An interface specification is used to track interface declarations
func = meth.__func__ func = meth.__func__
else: else:
func = meth func = meth
return fromFunction(func, interface, imlevel=1, name=name) return fromFunction(func, interface, imlevel=1, name=name)
# Now we can create the interesting interfaces and wire them up: # Now we can create the interesting interfaces and wire them up:
def _wire(): def _wire():
from zope.interface.declarations import classImplements from .declarations import classImplements
from zope.interface.interfaces import IAttribute from .interfaces import IAttribute
classImplements(Attribute, IAttribute) classImplements(Attribute, IAttribute)
from zope.interface.interfaces import IMethod from .interfaces import IMethod
classImplements(Method, IMethod) classImplements(Method, IMethod)
from zope.interface.interfaces import IInterface from .interfaces import IInterface
classImplements(InterfaceClass, IInterface) classImplements(InterfaceClass, IInterface)
from zope.interface.interfaces import ISpecification from .interfaces import ISpecification
classImplements(Specification, ISpecification) classImplements(Specification, ISpecification)
# We import this here to deal with module dependencies. # We import this here to deal with module dependencies.
from zope.interface.declarations import implementedBy from .declarations import implementedBy
from zope.interface.declarations import providedBy from .declarations import providedBy
from zope.interface.exceptions import InvalidInterface from .exceptions import InvalidInterface
from zope.interface.exceptions import BrokenImplementation from .exceptions import BrokenImplementation

mercurial/thirdparty/zope/interface/interfaces.py

############################################################################## ##############################################################################
# #
# Copyright (c) 2002 Zope Foundation and Contributors. # Copyright (c) 2002 Zope Foundation and Contributors.
# All Rights Reserved. # All Rights Reserved.
# #
# This software is subject to the provisions of the Zope Public License, # This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. # Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE. # FOR A PARTICULAR PURPOSE.
# #
############################################################################## ##############################################################################
"""Interface Package Interfaces """Interface Package Interfaces
""" """
from __future__ import absolute_import
__docformat__ = 'restructuredtext' __docformat__ = 'restructuredtext'
from zope.interface.interface import Attribute from .interface import Attribute
from zope.interface.interface import Interface from .interface import Interface
from zope.interface.declarations import implementer from .declarations import implementer
_BLANK = u'' _BLANK = u''
class IElement(Interface): class IElement(Interface):
"""Objects that have basic documentation and tagged values. """Objects that have basic documentation and tagged values.
""" """
... ...
classImplements(C, IA, IB. IC) classImplements(C, IA, IB. IC)
classImplementsOnly(C. I1, I2) classImplementsOnly(C. I1, I2)
Instances of ``C`` provide only ``I1``, ``I2``, and regardless of Instances of ``C`` provide only ``I1``, ``I2``, and regardless of
whatever interfaces instances of ``A`` and ``B`` implement. whatever interfaces instances of ``A`` and ``B`` implement.
""" """
def implementer_only(*interfaces): def implementer_only(*interfaces):
"""Create a decorator for declaring the only interfaces implemented """Create a decorator for declaring the only interfaces implemented
A callable is returned that makes an implements declaration on A callable is returned that makes an implements declaration on
objects passed to it. objects passed to it.
""" """
def directlyProvidedBy(object): def directlyProvidedBy(object):
"""Return the interfaces directly provided by the given object """Return the interfaces directly provided by the given object
The value returned is an IDeclaration. The value returned is an IDeclaration.

mercurial/thirdparty/zope/interface/registry.py

############################################################################## ##############################################################################
# #
# Copyright (c) 2006 Zope Foundation and Contributors. # Copyright (c) 2006 Zope Foundation and Contributors.
# All Rights Reserved. # All Rights Reserved.
# #
# This software is subject to the provisions of the Zope Public License, # This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. # Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE. # FOR A PARTICULAR PURPOSE.
# #
############################################################################## ##############################################################################
"""Basic components support """Basic components support
""" """
from __future__ import absolute_import
from collections import defaultdict from collections import defaultdict
try: try:
from zope.event import notify from ..event import notify
except ImportError: # pragma: no cover except ImportError: # pragma: no cover
def notify(*arg, **kw): pass def notify(*arg, **kw): pass
from zope.interface.interfaces import ISpecification from .interfaces import ISpecification
from zope.interface.interfaces import ComponentLookupError from .interfaces import ComponentLookupError
from zope.interface.interfaces import IAdapterRegistration from .interfaces import IAdapterRegistration
from zope.interface.interfaces import IComponents from .interfaces import IComponents
from zope.interface.interfaces import IHandlerRegistration from .interfaces import IHandlerRegistration
from zope.interface.interfaces import ISubscriptionAdapterRegistration from .interfaces import ISubscriptionAdapterRegistration
from zope.interface.interfaces import IUtilityRegistration from .interfaces import IUtilityRegistration
from zope.interface.interfaces import Registered from .interfaces import Registered
from zope.interface.interfaces import Unregistered from .interfaces import Unregistered
from zope.interface.interface import Interface from .interface import Interface
from zope.interface.declarations import implementedBy from .declarations import implementedBy
from zope.interface.declarations import implementer from .declarations import implementer
from zope.interface.declarations import implementer_only from .declarations import implementer_only
from zope.interface.declarations import providedBy from .declarations import providedBy
from zope.interface.adapter import AdapterRegistry from .adapter import AdapterRegistry
from zope.interface._compat import CLASS_TYPES from ._compat import CLASS_TYPES
from zope.interface._compat import STRING_TYPES from ._compat import STRING_TYPES
class _UnhashableComponentCounter(object): class _UnhashableComponentCounter(object):
# defaultdict(int)-like object for unhashable components # defaultdict(int)-like object for unhashable components
def __init__(self, otherdict): def __init__(self, otherdict):
# [(component, count)] # [(component, count)]
self._data = [item for item in otherdict.items()] self._data = [item for item in otherdict.items()]

mercurial/thirdparty/zope/interface/ro.py

############################################################################## ##############################################################################
# #
# Copyright (c) 2003 Zope Foundation and Contributors. # Copyright (c) 2003 Zope Foundation and Contributors.
# All Rights Reserved. # All Rights Reserved.
# #
# This software is subject to the provisions of the Zope Public License, # This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. # Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE. # FOR A PARTICULAR PURPOSE.
# #
############################################################################## ##############################################################################
"""Compute a resolution order for an object and its bases """Compute a resolution order for an object and its bases
""" """
from __future__ import absolute_import
__docformat__ = 'restructuredtext' __docformat__ = 'restructuredtext'
def _mergeOrderings(orderings): def _mergeOrderings(orderings):
"""Merge multiple orderings so that within-ordering order is preserved """Merge multiple orderings so that within-ordering order is preserved
Orderings are constrained in such a way that if an object appears Orderings are constrained in such a way that if an object appears
in two or more orderings, then the suffix that begins with the in two or more orderings, then the suffix that begins with the
object must be in both orderings. object must be in both orderings.

mercurial/thirdparty/zope/interface/verify.py

############################################################################## ##############################################################################
# #
# Copyright (c) 2001, 2002 Zope Foundation and Contributors. # Copyright (c) 2001, 2002 Zope Foundation and Contributors.
# All Rights Reserved. # All Rights Reserved.
# #
# This software is subject to the provisions of the Zope Public License, # This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. # Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE. # FOR A PARTICULAR PURPOSE.
# #
############################################################################## ##############################################################################
"""Verify interface implementations """Verify interface implementations
""" """
from zope.interface.exceptions import BrokenImplementation, DoesNotImplement from __future__ import absolute_import
from zope.interface.exceptions import BrokenMethodImplementation
from .exceptions import BrokenImplementation, DoesNotImplement
from .exceptions import BrokenMethodImplementation
from types import FunctionType, MethodType from types import FunctionType, MethodType
from zope.interface.interface import fromMethod, fromFunction, Method from .interface import fromMethod, fromFunction, Method
import sys import sys
# This will be monkey-patched when running under Zope 2, so leave this # This will be monkey-patched when running under Zope 2, so leave this
# here: # here:
MethodTypes = (MethodType, ) MethodTypes = (MethodType, )
def _verify(iface, candidate, tentative=0, vtype=None): def _verify(iface, candidate, tentative=0, vtype=None):