Old version of CHANLIMIT.
357907
async def on_isupport_maxchannels(self, value):
        
        if 'CHANTYPES' in self._isupport and 'CHANLIMIT' not in self._isupport:
            self._channel_limits = {}

            prefixes = self._isupport['CHANTYPES']
            # Assume the limit is for all types of channels. Make a single group for all types.
            self._channel_limits[frozenset(prefixes)] = int(value)
            for prefix in prefixes:
                self._channel_limit_groups[prefix] = frozenset(prefixes)
1279379
def deprecated(context):
    """"""
    if 'fileFormatIn' in context:
        context.assert_keys_have_values(__name__,
                                        'fileFormatIn',
                                        'fileFormatOut')

        context['fileFormat'] = {'in': context['fileFormatIn'],
                                 'out': context['fileFormatOut']}

        logger.warning("fileFormatIn and fileFormatOut "
                       "are deprecated. They will stop working upon the next "
                       "major release. Use the new context key fileFormat "
                       "instead. It's a lot better, promise! For the moment "
                       "pypyr is creating the new fileFormat key for you "
                       "under the hood.")
819017
def deprecated(func):
    """"""

    @functools.wraps(func)
    def new_func(*args, **kwargs):
        if PY3K:
            func_code = func.__code__
        else:
            func_code = func.func_code

        warnings.warn_explicit(
            "Call to deprecated function {}.".format(func.__name__),
            category=DeprecationWarning,
            filename=func_code.co_filename,
            lineno=func_code.co_firstlineno + 1,
        )

        return func(*args, **kwargs)

    return new_func
939001
function () {

		var old = view.lists,
			data;

		view.lists = function (list, renderer) {
			data = {
				list: list,
				renderer: renderer
			};
			return Math.random();
		};
		// sets back to the old data
		return function () {
			view.lists = old;
			return data;
		};
	}
493794
def mugshot2to3(old):
    
    new = old.upgradeVersion(Mugshot.typeName, 2, 3,
                             person=old.person,
                             type=old.type,
                             body=old.body,
                             smallerBody=old.smallerBody)
    new.smallerBody = new.makeThumbnail(
        new.body.open(), new.person, new.type[len('image/'):], smaller=True)
    return new
1008328
def deprecated(context):
    """"""
    tar = context.get('tar', None)

    # at least 1 of tarExtract or tarArchive must exist in context
    tar_extract, tar_archive = context.keys_of_type_exist(
        ('tarExtract', list),
        ('tarArchive', list))

    found_at_least_one = (tar_extract.key_in_context
                          or tar_archive.key_in_context)

    if tar and not found_at_least_one:
        return
    elif found_at_least_one:
        tar = context['tar'] = {}

    if tar_extract.key_in_context and tar_extract.is_expected_type:
        tar['extract'] = context[tar_extract.key]

    if tar_archive.key_in_context and tar_archive.is_expected_type:
        tar['archive'] = context[tar_archive.key]

    if 'tarFormat' in context:
        tar['format'] = context['tarFormat']

    logger.warning("tarExtract and tarArchive are deprecated. They will "
                   "stop working upon the next major release. "
                   "Use the new context key env instead. It's a lot "
                   "better, promise! For the moment pypyr is creating the "
                   "new env key for you under the hood.")
19542
function istanbulLoader(m, filename, old) {
  istanbulMonkey[filename] = true;
  old(m, filename);
}
1317877
function (image, old) {
        var data1 = old.data,
            data2 = image.data,
            w1 = old.width,
            w2 = image.width,
            px1 = old.globalOffset.x,
            py1 = old.globalOffset.y,
            px2 = image.globalOffset.x,
            py2 = image.globalOffset.y,
            b1 = old.bounds,
            b2 = image.bounds,
            px = Math.min(b1.minX + px1, b2.minX + px2), // global offset for new image (by min in bounds)
            py = Math.min(b1.minY + py1, b2.minY + py2),
            b = { // bounds for new image include all of the pixels [0,0,width,height] (reduce to bounds)
                minX: 0,
                minY: 0,
                maxX: Math.max(b1.maxX + px1, b2.maxX + px2) - px,
                maxY: Math.max(b1.maxY + py1, b2.maxY + py2) - py,
            },
            w = b.maxX + 1, // size for new image
            h = b.maxY + 1,
            i, j, k, k1, k2, len;

        var result = new Uint8Array(w * h);

        // copy all old image
        len = b1.maxX - b1.minX + 1;
        i = (py1 - py + b1.minY) * w + (px1 - px + b1.minX);
        k1 = b1.minY * w1 + b1.minX;
        k2 = b1.maxY * w1 + b1.minX + 1;
        // walk through rows (Y)
        for (k = k1; k < k2; k += w1) {
            result.set(data1.subarray(k, k + len), i); // copy row
            i += w;
        }

        // copy new image (only "black" pixels)
        len = b2.maxX - b2.minX + 1;
        i = (py2 - py + b2.minY) * w + (px2 - px + b2.minX);
        k1 = b2.minY * w2 + b2.minX;
        k2 = b2.maxY * w2 + b2.minX + 1;
        // walk through rows (Y)
        for (k = k1; k < k2; k += w2) {
            // walk through cols (X)
            for (j = 0; j < len; j++) {
                if (data2[k + j] === 1) result[i + j] = 1;
            }
            i += w;
        }

        return {
            data: result,
            width: w,
            height: h,
            bounds: b,
            globalOffset: {
                x: px,
                y: py,
            }
        };
    }
361049
function(newval, oldval) {
		if ([newval, oldval].every(function(val) {
			return val.contains('edbml.$');
		})) {
			var newkeys = gui.KeyMaster.extractKey(newval);
			var oldkeys = gui.KeyMaster.extractKey(oldval);
			if (newkeys && oldkeys) {
				oldkeys.forEach(function(oldkey, i) {
					var newkey = newkeys[i];
					newval = newval.replace(newkey, '');
					oldval = oldval.replace(oldkey, '');
					this._functions[oldkey] = newkey;
				}, this);
				return newval === oldval;
			}
		}
		return false;
	}
740906
def precompute_old
      warn "This method should not be used, please use precompute instead."
      word_list.rewind.each do |line|
        word = line.chomp
        precomputed_list_old[word.split('').sort.join.freeze] += [word]
      end
    end
62095
def purge_obsolete_samples(self, config, now):
        
        expire_age = config.samples * config.time_window_ms
        for sample in self._samples:
            if now - sample.last_window_ms >= expire_age:
                sample.reset(now)
753857
function (oldData) {
    var data = this.data;
    var el = this.el;
    var raycaster = this.raycaster;

    // Set raycaster properties.
    raycaster.far = data.far;
    raycaster.near = data.near;

    // Draw line.
    if (data.showLine &&
        (data.far !== oldData.far || data.origin !== oldData.origin ||
         data.direction !== oldData.direction || !oldData.showLine)) {
      // Calculate unit vector for line direction. Can be multiplied via scalar to performantly
      // adjust line length.
      this.unitLineEndVec3.copy(data.origin).add(data.direction).normalize();
      this.drawLine();
    }

    if (!data.showLine && oldData.showLine) {
      el.removeAttribute('line');
    }

    if (data.objects !== oldData.objects && !OBSERVER_SELECTOR_RE.test(data.objects)) {
      warn('[raycaster] Selector "' + data.objects +
           '" may not update automatically with DOM changes.');
    }

    if (!data.objects) {
      warn('[raycaster] For performance, please define raycaster.objects when using ' +
           'raycaster or cursor components to whitelist which entities to intersect with. ' +
           'e.g., raycaster="objects: [data-raycastable]".');
    }

    if (data.autoRefresh !== oldData.autoRefresh && el.isPlaying) {
      data.autoRefresh
        ? this.addEventListeners()
        : this.removeEventListeners();
    }

    if (oldData.enabled && !data.enabled) { this.clearAllIntersections(); }

    this.setDirty();
  }
1002218
public void
apply(Message m, TSIGRecord old) {
	apply(m, Rcode.NOERROR, old);
}
1275620
function _oldStyleShareReplay (bufferSize, windowTime, scheduler) {
  let subject;

  const connectable = multicast(function shareReplaySubjectFactory () {
    if (this._isComplete) {
      return subject;
    } else {
      return (subject = new ReplaySubject(bufferSize, windowTime, scheduler));
    }
  });
  return (source) => refCount()(connectable(source));
}
754839
def old_items(mtime=(Time.now.to_i)-(172800))
      data = db.execute <<SQL
        SELECT * from artifacts where modified < #{mtime}
SQL
      data || []
    end
1208980
def deprecated(fn):
    """"""
    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        warnings.warn(fn.__doc__.split('\n')[0],
                      category=DeprecationWarning, stacklevel=2)
        return fn(*args, **kwargs)
    return wrapper
504399
def version():
    '''
    
    '''
    ret = {}
    cmd = 'imgadm --version'
    res = __salt__['cmd.run'](cmd).splitlines()
    ret = res[0].split()
    return ret[-1]