.. deprecated:: 2018.2.0
           Use :class:`MecanumDrivetrain` instead
517092
def mecanum_drivetrain(
    lr_motor,
    rr_motor,
    lf_motor,
    rf_motor,
    x_wheelbase=2,
    y_wheelbase=3,
    speed=5,
    deadzone=None,
):
    
    return MecanumDrivetrain(x_wheelbase, y_wheelbase, speed, deadzone).get_vector(
        lr_motor, rr_motor, lf_motor, rf_motor
    )
673245
public void driveToClass( String classname ) {
        String [] sa = BshClassPath.splitClassname( classname );
        String packn = sa[0];
        String classn = sa[1];

        // Do we have the package?
        if ( classPath.getClassesForPackage(packn).size()==0 )
            return;

        ptree.setSelectedPackage( packn );

        for(int i=0; i< classesList.length; i++) {
            if ( classesList[i].equals(classn) ) {
                classlist.setSelectedIndex(i);
                classlist.ensureIndexIsVisible(i);
                break;
            }
        }
    }
929379
def deprecated(replacement_description):
    

    def decorate(fn_or_class):
        if isinstance(fn_or_class, type):
            pass  # Can't change __doc__ of type objects
        else:
            try:
                fn_or_class.__doc__ = "This API point is obsolete. %s\n\n%s" % (
                    replacement_description,
                    fn_or_class.__doc__,
                )
            except AttributeError:
                pass  # For Cython method descriptors, etc.
        return fn_or_class

    return decorate
815848
def on_train_end(self, **kwargs):
        ""
        if self.every=="improvement" and (self.learn.path/f'{self.learn.model_dir}/{self.name}.pth').is_file():
            self.learn.load(f'{self.name}', purge=False)
120431
def _from_deprecated_son(cls, id_dict, run):
        """"""
        cls._deprecation_warning()
        return AssetLocator._from_deprecated_son(id_dict, run)
1200605
private void buildDeprecatedAPIInfo() {
        SortedSet<Element> rset = deprecatedMap.get(DeprElementKind.REMOVAL);
        SortedSet<ModuleElement> modules = configuration.modules;
        SortedSet<Element> mset = deprecatedMap.get(DeprElementKind.MODULE);
        for (Element me : modules) {
            if (utils.isDeprecatedForRemoval(me)) {
                rset.add(me);
            }
            if (utils.isDeprecated(me)) {
                mset.add(me);
            }
        }
        SortedSet<PackageElement> packages = configuration.packages;
        SortedSet<Element> pset = deprecatedMap.get(DeprElementKind.PACKAGE);
        for (Element pe : packages) {
            if (utils.isDeprecatedForRemoval(pe)) {
                rset.add(pe);
            }
            if (utils.isDeprecated(pe)) {
                pset.add(pe);
            }
        }
        for (Element e : configuration.getIncludedTypeElements()) {
            TypeElement te = (TypeElement)e;
            SortedSet<Element> eset;
            if (utils.isDeprecatedForRemoval(e)) {
                rset.add(e);
            }
            if (utils.isDeprecated(e)) {
                switch (e.getKind()) {
                    case ANNOTATION_TYPE:
                        eset = deprecatedMap.get(DeprElementKind.ANNOTATION_TYPE);
                        eset.add(e);
                        break;
                    case CLASS:
                        if (utils.isError(te)) {
                            eset = deprecatedMap.get(DeprElementKind.ERROR);
                        } else if (utils.isException(te)) {
                            eset = deprecatedMap.get(DeprElementKind.EXCEPTION);
                        } else {
                            eset = deprecatedMap.get(DeprElementKind.CLASS);
                        }
                        eset.add(e);
                        break;
                    case INTERFACE:
                        eset = deprecatedMap.get(DeprElementKind.INTERFACE);
                        eset.add(e);
                        break;
                    case ENUM:
                        eset = deprecatedMap.get(DeprElementKind.ENUM);
                        eset.add(e);
                        break;
                }
            }
            composeDeprecatedList(rset, deprecatedMap.get(DeprElementKind.FIELD),
                    utils.getFields(te));
            composeDeprecatedList(rset, deprecatedMap.get(DeprElementKind.METHOD),
                    utils.getMethods(te));
            composeDeprecatedList(rset, deprecatedMap.get(DeprElementKind.CONSTRUCTOR),
                    utils.getConstructors(te));
            if (utils.isEnum(e)) {
                composeDeprecatedList(rset, deprecatedMap.get(DeprElementKind.ENUM_CONSTANT),
                        utils.getEnumConstants(te));
            }
            if (utils.isAnnotationType(e)) {
                composeDeprecatedList(rset, deprecatedMap.get(DeprElementKind.ANNOTATION_TYPE_MEMBER),
                        utils.getAnnotationMembers(te));

            }
        }
    }
601465
def deprecated(context):
    """"""
    if 'fetchJsonPath' in context:
        context.assert_key_has_value(key='fetchJsonPath', caller=__name__)

        context['fetchJson'] = {'path': context['fetchJsonPath']}

        if 'fetchJsonKey' in context:
            context['fetchJson']['key'] = context.get('fetchJsonKey', None)

        logger.warning("fetchJsonPath and fetchJsonKey "
                       "are deprecated. They will stop working upon the next "
                       "major release. Use the new context key fetchJson "
                       "instead. It's a lot better, promise! For the moment "
                       "pypyr is creating the new fetchJson key for you "
                       "under the hood.")
585551
@Deprecated
	protected Map<String, Helper> helpers() {
		Map<String, Helper> helpers = new HashMap<>();
		helpers.put(HandlebarsJsonPathHelper.NAME, new HandlebarsJsonPathHelper());
		helpers.put(HandlebarsEscapeHelper.NAME, new HandlebarsEscapeHelper());
		return helpers;
	}
1238596
def txt2mecab(text, **kwargs):
    '''  '''
    mecab_out = _internal_mecab_parse(text, **kwargs).splitlines()
    tokens = [MeCabToken.parse(x) for x in mecab_out]
    return MeCabSent(text, tokens)
714599
def update_class_by_type(old, new):
    
    autoreload.update_class(old, new)
    if isinstance2(old, new, AtomMeta):
        update_atom_members(old, new)
936265
@java.lang.Deprecated
  public java.util.Map<java.lang.String, java.lang.Integer> getDriverLogLevelsValue() {
    return getDriverLogLevelsValueMap();
  }
617307
def make_deprecated_class(oldname, NewClass):
    
    msg = ("{module}.{} has been renamed to {module}.{}"
           .format(oldname, NewClass.__name__, module=NewClass.__module__))

    class OldClass(NewClass):
        def __new__(cls, *args, **kwargs):
            raise NotImplementedError(msg)
    OldClass.__doc__ = msg
    OldClass.__qualname__ = OldClass.__name__ = oldname
    return OldClass
1041818
def train(self):
    
    for iDriving, cDriving in enumerate(self.drivingOperandSDRs):
      minicolumnSDR = self.minicolumnSDRs[iDriving]
      self.pairLayerProximalConnections.associate(minicolumnSDR, cDriving)
      for iContext, cContext in enumerate(self.contextOperandSDRs):
        iResult = (iContext + iDriving) % self.numLocations
        cResult = self.resultSDRs[iResult]
        self.pairLayer.compute(minicolumnSDR, basalInput=cContext)
        cPair = self.pairLayer.getWinnerCells()
        self.poolingLayer.associate(cResult, cPair)
1180589
def deserialize(cls, v):
        
        if v is None:
            return None
        if cls == Gear and v.get('resource_state') == 3:
            if 'frame_type' in v:
                o = Bike()
            else:
                o = Shoe()
        else:
            o = cls()
        o.from_dict(v)
        return o
627961
def update_build_trains!(app_id, testing_type, data)
      raise "app_id is required" unless app_id

      # The request fails if this key is present in the data
      data.delete("dailySubmissionCountByPlatform")

      r = request(:post) do |req|
        req.url("ra/apps/#{app_id}/testingTypes/#{testing_type}/trains/")
        req.body = data.to_json
        req.headers['Content-Type'] = 'application/json'
      end

      handle_itc_response(r.body)
    end
939830
@Deprecated
  private void emitJvmMemMetrics(ServiceEmitter emitter)
  {
    // I have no idea why, but jvm/mem is slightly more than the sum of jvm/pool. Let's just include
    // them both.
    final Map<String, MemoryUsage> usages = ImmutableMap.of(
        "heap", ManagementFactory.getMemoryMXBean().getHeapMemoryUsage(),
        "nonheap", ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage()
    );
    for (Map.Entry<String, MemoryUsage> entry : usages.entrySet()) {
      final String kind = entry.getKey();
      final MemoryUsage usage = entry.getValue();
      final ServiceMetricEvent.Builder builder = builder().setDimension("memKind", kind);
      MonitorUtils.addDimensionsToBuilder(builder, dimensions);

      emitter.emit(builder.build("jvm/mem/max", usage.getMax()));
      emitter.emit(builder.build("jvm/mem/committed", usage.getCommitted()));
      emitter.emit(builder.build("jvm/mem/used", usage.getUsed()));
      emitter.emit(builder.build("jvm/mem/init", usage.getInit()));
    }

    // jvm/pool
    for (MemoryPoolMXBean pool : ManagementFactory.getMemoryPoolMXBeans()) {
      final String kind = pool.getType() == MemoryType.HEAP ? "heap" : "nonheap";
      final MemoryUsage usage = pool.getUsage();
      final ServiceMetricEvent.Builder builder = builder()
          .setDimension("poolKind", kind)
          .setDimension("poolName", pool.getName());
      MonitorUtils.addDimensionsToBuilder(builder, dimensions);

      emitter.emit(builder.build("jvm/pool/max", usage.getMax()));
      emitter.emit(builder.build("jvm/pool/committed", usage.getCommitted()));
      emitter.emit(builder.build("jvm/pool/used", usage.getUsed()));
      emitter.emit(builder.build("jvm/pool/init", usage.getInit()));
    }
  }
310099
def wagon_class(spec)
      @wagon_classes ||= {}
      return @wagon_classes[spec] if @wagon_classes.key?(spec)

      clazz = nil
      file = File.join(spec.gem_dir, 'lib', spec.name, 'wagon.rb')
      if File.exist?(file)
        require file
        clazz = "#{spec.name.camelize}::Wagon".constantize
      else
        fail "#{spec.name} wagon class not found in #{file}"
      end
      @wagon_classes[spec] = clazz
    end