Yield all ``(object, property)`` pairs where the two definitions disagree.
190340
def conflicting_pairs(left, right):
    """"""
    objects = left._objects & right._objects
    properties = left._properties & right._properties
    difference = left._pairs ^ right._pairs
    for o in objects:
        for p in properties:
            if (o, p) in difference:
                yield (o, p)
1307661
def get_pairwise(self, cls=None, **kwargs):
        
        for set_of_values in allpairs(kwargs.values()):
            case = cls() if cls else self._CasesClass()
            for attr, value in izip(kwargs.keys(), set_of_values):
                setattr(case, attr, value)
            yield case
1217089
def _triplify_object(self, data, parent):
        
        subject = self.get_subject(data)
        if self.path:
            yield (subject, TYPE_SCHEMA, self.path, TYPE_SCHEMA)

        if parent is not None:
            yield (parent, self.predicate, subject, TYPE_LINK)
            if self.reverse is not None:
                yield (subject, self.reverse, parent, TYPE_LINK)

        for prop in self.properties:
            for res in prop.triplify(data.get(prop.name), subject):
                yield res
988082
def implfuncs(self):
    """"""
    for f in self.body:
        if (hasattr(f, '_ctype')
                and isinstance(f._ctype, FuncType)
                and hasattr(f, 'body')):
            yield f
975058
function _applyProp(property, value, obj) {
      obj = obj || {};
      obj[property] = value;
      return obj;
    }
1279641
def _infer_dict(obj):
    '''
    '''
    for ats in (('__len__', 'get', 'has_key',     'items',     'keys',     'values'),
                ('__len__', 'get', 'has_key', 'iteritems', 'iterkeys', 'itervalues')):
        for a in ats:  # no all(<generator_expression>) in Python 2.2
            if not _callable(getattr(obj, a, None)):
                break
        else:  # all True
            return True
    return False
787202
function defineProp (obj, name, fn) {
  Object.defineProperty(obj, name, {
    enumerable: true,
    configurable: true,
    get: function () {
      return fn();
    }
  });
}
241206
function iterateOverObject(obj) {
  const props = keys(obj);
  const output = {};
  props.forEach(function iterateOverProps(prop) {
    const val = obj[prop];
    const type = typeof val;
    if (type === 'string' && BLACK_LIST_PROPS.indexOf(prop) === -1) {
      output[prop] = escape(val);
    } else if (type === 'object') {
      if (prop !== '#multi') {
        output[prop] = iterateOverObject(val);
      } else {
        output[prop] = val;
        val.match = escape(val.match);
      }
    } else {
      output[prop] = val;
    }
  });

  return output;
}
966753
def tuples_to_coll(cls, generator, coerce=False):
        
        if cls != Collection:
            raise exc.CollectionDefinitionError(
                property='tuples_to_coll',
                coll='Collection',
            )
1034480
def xflatten(iterable, transform, check=is_iterable):
    """"""
    for value in transform(iterable):
        if check(value):
            for flat in xflatten(value, transform, check):
                yield flat
        else:
            yield value
609973
function defProp(obj, prop, val) {
    var desc = defProp.desc || (
      defProp.desc = {
        enumerable: false,
        writable: false,
        configurable: false,
        value: null
      }
    );
    desc.value = val;
    Object.defineProperty(obj, prop, desc);
  }
97227
function (object, property) {
        return utils.getProp(object, Array.prototype.slice.call(arguments, 1).join("."));
    }
392009
function each(obj, iter) {
  for (var key in obj) {
    if (obj.hasOwnProperty(key)) iter(key, obj[key]);
  }
}
926731
function each (obj, fn) {
		const nth = obj.length;
		let i = -1;

		while (++i < nth) {
			if (fn.call(obj, obj[i], i) === false) {
				break;
			}
		}

		return obj;
	}
762644
def ensure_compatible(left, right):
    """"""
    conflicts = list(conflicting_pairs(left, right))
    if conflicts:
        raise ValueError('conflicting values for object/property pairs: %r' % conflicts)
366105
def coerce(cls, key, value):
        """"""
        if value is None:
            return value
        if isinstance(value, cls):
            return value
        if isinstance(value, dict):
            return NestedMutableDict.coerce(key, value)
        if isinstance(value, list):
            return NestedMutableList.coerce(key, value)
        return super(cls).coerce(key, value)
456040
def _AtNonLeaf(self, attr_value, path):
    """"""
    if isinstance(attr_value, dict):
      for value in self.Expand(attr_value, path[1:]):
        yield value
    else:
      for v in objectfilter.ValueExpander._AtNonLeaf(self, attr_value, path):
        yield v