Returns the current kernel.

        :return: the kernel or None if none found
        :rtype: Kernel
550448
def kernel(self):
        
        result = javabridge.static_call(
            "weka/classifiers/KernelHelper", "getKernel",
            "(Ljava/lang/Object;)Lweka/classifiers/functions/supportVector/Kernel;",
            self.jobject)
        if result is None:
            return None
        else:
            return Kernel(jobject=result)
747858
def get_current_desktop(self):
        
        desktop = ctypes.c_long(0)
        _libxdo.xdo_get_current_desktop(self._xdo, ctypes.byref(desktop))
        return desktop.value
744042
def _kernel(kernel_spec):
  
  if isinstance(kernel_spec, tf.compat.integral_types):
    return [kernel_spec, kernel_spec]
  elif len(kernel_spec) == 1:
    return [kernel_spec[0], kernel_spec[0]]
  else:
    assert len(kernel_spec) == 2
    return kernel_spec
72988
def kernel_version():
    
    kver = check_output(['uname', '-r']).decode('UTF-8').strip()
    kver = kver.split('.')
    return (int(kver[0]), int(kver[1]))
1028266
def current(class_):
		""
		tzi = class_()
		kernel32 = ctypes.windll.kernel32
		getter = kernel32.GetTimeZoneInformation
		getter = getattr(kernel32, 'GetDynamicTimeZoneInformation', getter)
		code = getter(ctypes.byref(tzi))
		return code, tzi
905505
function current() {
        $statement = parent::current();
        
        $triple = new core_kernel_classes_Triple();
        $triple->modelid = $statement["modelid"];
        $triple->subject = $statement["subject"];
        $triple->predicate = $statement["predicate"];
        $triple->object = $statement["object"];
        $triple->id = $statement["id"];
        $triple->lg = $statement["l_language"];
        $triple->author = $statement["author"];
        return $triple;
    }
68189
def kernel(self):
        
        stop_words = [ y.lower() for y in self.abbreviations.values() + self.filler_words ]
        kernel = ' '.join([ x for x in self.expand().split() if x.lower() not in stop_words ])

        # this is a hack to get around the fact that this is the only two-word phrase we want to block
        # amongst our stop words. if we end up with more, we may need a better way to do this
        kernel = re.sub(r'\s*United States', '', kernel)

        return kernel
896602
def find_kernel_specs(self):
        """"""
        # let real installed kernels overwrite envs with the same name:
        # this is the same order as the get_kernel_spec way, which also prefers
        # kernels from the jupyter dir over env kernels.
        specs = self.find_kernel_specs_for_envs()
        specs.update(super(EnvironmentKernelSpecManager,
                           self).find_kernel_specs())
        return specs
620571
def get_shell(self):
        
        if (not hasattr(self.shell, 'get_doc') or
                (hasattr(self.shell, 'is_running') and
                 not self.shell.is_running())):
            self.shell = None
            if self.main.ipyconsole is not None:
                shell = self.main.ipyconsole.get_current_shellwidget()
                if shell is not None and shell.kernel_client is not None:
                    self.shell = shell
            if self.shell is None:
                self.shell = self.internal_shell
        return self.shell
888556
def current(self):
        
        if not self.started:
            return None
        return count_group(self.group, cached=self.cached)
1254397
protected function getKernal()
    {
        if (!$this->kernel) {
            $this->kernel = file_get_contents($this->kernel_filename);
        }

        return $this->kernel;
    }
143752
def get_core(self):
        

        if self.lingeling and self.status == False:
            return pysolvers.lingeling_core(self.lingeling, self.prev_assumps)
1301495
def Instance(self):
        
        try:
            return self._instance
        except AttributeError:
            self._instance = self._decorated()
            return self._instance
300434
def get_current_generator(self):
        """"""
        int_index=int(len(self.generators)*wrap(0,1.0,self.inspect_value('index')))
        return self.generators[int_index]
799797
def get_current_structure(self):
        

        struct = self.__class__.get_structure()
        struct.update(self.__field_types__)
        return struct
64553
def getEngineRoot(self):
		
		if not hasattr(self, '_engineRoot'):
			self._engineRoot = self._getEngineRoot()
		return self._engineRoot
915962
def get_kernel_id(self):
        
        sessions_url = self.get_session_url()
        sessions_req = requests.get(sessions_url).content.decode()
        sessions = json.loads(sessions_req)

        if os.name == 'nt':
            path = self.path.replace('\\', '/')
        else:
            path = self.path

        for session in sessions:
            notebook_path = session.get('notebook', {}).get('path')
            if notebook_path is not None and notebook_path == path:
                kernel_id = session['kernel']['id']
                return kernel_id