return a suitable class to operate
18366
def _create_storer(self, group, format=None, value=None, append=False,
                       **kwargs):
        

        def error(t):
            raise TypeError(
                "cannot properly create the storer for: [{t}] [group->"
                "{group},value->{value},format->{format},append->{append},"
                "kwargs->{kwargs}]".format(t=t, group=group,
                                           value=type(value), format=format,
                                           append=append, kwargs=kwargs))

        pt = _ensure_decoded(getattr(group._v_attrs, 'pandas_type', None))
        tt = _ensure_decoded(getattr(group._v_attrs, 'table_type', None))

        # infer the pt from the passed value
        if pt is None:
            if value is None:

                _tables()
                if (getattr(group, 'table', None) or
                        isinstance(group, _table_mod.table.Table)):
                    pt = 'frame_table'
                    tt = 'generic_table'
                else:
                    raise TypeError(
                        "cannot create a storer if the object is not existing "
                        "nor a value are passed")
            else:

                try:
                    pt = _TYPE_MAP[type(value)]
                except KeyError:
                    error('_TYPE_MAP')

                # we are actually a table
                if format == 'table':
                    pt += '_table'

        # a storer node
        if 'table' not in pt:
            try:
                return globals()[_STORER_MAP[pt]](self, group, **kwargs)
            except KeyError:
                error('_STORER_MAP')

        # existing node (and must be a table)
        if tt is None:

            # if we are a writer, determine the tt
            if value is not None:

                if pt == 'series_table':
                    index = getattr(value, 'index', None)
                    if index is not None:
                        if index.nlevels == 1:
                            tt = 'appendable_series'
                        elif index.nlevels > 1:
                            tt = 'appendable_multiseries'
                elif pt == 'frame_table':
                    index = getattr(value, 'index', None)
                    if index is not None:
                        if index.nlevels == 1:
                            tt = 'appendable_frame'
                        elif index.nlevels > 1:
                            tt = 'appendable_multiframe'
                elif pt == 'wide_table':
                    tt = 'appendable_panel'
                elif pt == 'ndim_table':
                    tt = 'appendable_ndim'

            else:

                # distiguish between a frame/table
                tt = 'legacy_panel'
                try:
                    fields = group.table._v_attrs.fields
                    if len(fields) == 1 and fields[0] == 'value':
                        tt = 'legacy_frame'
                except IndexError:
                    pass

        try:
            return globals()[_TABLE_MAP[tt]](self, group, **kwargs)
        except KeyError:
            error('_TABLE_MAP')
980822
def _make_class(cls, **kwargs):
    """"""
    kwargs = {k: (v if v is not None else getattr(cls, k, None))
              for k, v in kwargs.items()}
    # The class name contains a hash of the custom parameters.
    name = cls.__name__ + '_' + _hash(kwargs)
    if name not in _CLASSES:
        logger.log(5, "Create class %s %s.", name, kwargs)
        cls = type(name, (cls,), kwargs)
        _CLASSES[name] = cls
    return _CLASSES[name]
1084236
def class_method(cls, f):
        """"""
        setattr(cls, f.__name__, classmethod(f))
        return f
331187
def superclass(self, klass):
        """"""
        return bool(lib.EnvSuperclassP(self._env, self._cls, klass._cls))
780791
def service(self):
        '''
        
        '''
        service_class = getattr(self, 'service_class')
        service = service_class(self.http_request)
        return service
500571
def get(_class, api, vid):
        
        busses = api.vehicles(vid=vid)['vehicle']   
        return _class.fromapi(api, api.vehicles(vid=vid)['vehicle'])
26369
def find_class(self):
        """"""
        if self.value <= 1:
            return InstructionsProperty
        elif self.value <= 3:
            return NextTablesProperty
        elif self.value <= 7:
            return ActionsProperty

        return OxmProperty
626425
def bind(self, cls, instance):
        """"""
        self._check_class(cls)
        self._bindings[cls] = lambda: instance
        logger.debug('Bound %s to an instance %s', cls, instance)
        return self
627647
def get_superclass(self, class_):
        
        if not class_.is_loaded or class_.superclass_name is None:
            return None
        return self.get_class(class_.superclass_name)
934
def iterclass(cls):
    
    for field in dir(cls):
        if hasattr(cls, field):
            value = getattr(cls, field)
            yield field, value
1193754
def from_dict(cls, d):
        
        result = OptionHandler(cls.new_instance(d["class"]))
        result.options = split_options(d["options"])
        return result
907635
def run_operator(operator, revision, config):
    """"""
    instance = operator.cls(config)
    logger.debug(f"Running {operator.name} operator on {revision.key}")
    return operator.name, instance.run(revision, config)
933830
def find_class(self, name):
        """"""
        defclass = lib.EnvFindDefclass(self._env, name.encode())
        if defclass == ffi.NULL:
            raise LookupError("Class '%s' not found" % name)

        return Class(self._env, defclass)
542326
def _load_class(class_path):
    """"""
    parts = class_path.rsplit('.', 1)
    module = __import__(parts[0], fromlist=parts[1])
    return getattr(module, parts[1])
1372272
def _find_controller(self, class_):
        
        for controller, classes in self.request_controllers.items():
            if class_ in classes:
                return controller
        else:
            raise ValueError('Unknown request class {!r}'.format(class_))
643487
function getClass(o) {

	if (o === null || o === undefined) return "Object";
	return OP_toString.call(o).slice("[object ".length, -1);
}
105830
def response_class(self, cls):
        
        s = self._clone()
        s._response_class = cls
        return s