Home the robot.

        :returns: This instance.
5995
def home(self) -> 'InstrumentContext':
        
        def home_dummy(mount): pass
        cmds.do_publish(self.broker, cmds.home, home_dummy,
                        'before', None, None, self._mount.name.lower())
        self._hw_manager.hardware.home_z(self._mount)
        self._hw_manager.hardware.home_plunger(self._mount)
        cmds.do_publish(self.broker, cmds.home, home_dummy,
                        'after', self, None, self._mount.name.lower())
        return self
687028
def away(self):
        
        nest = self._last_reading.get('users_away', None)
        ecobee = self.profile()
        if nest is not None:
            return nest
        if ecobee is not None:
            if ecobee == "home":
                return False
            return True
        return None
833118
def from_robot(cls, robot, **kwargs):
        """"""
        m = cls(len(robot.m_feats), len(robot.s_feats), **kwargs)
        return m
1002731
def create_mackup_home(self):
        """"""
        if not os.path.isdir(self.mackup_folder):
            if utils.confirm("Mackup needs a directory to store your"
                             " configuration files\n"
                             "Do you want to create it now? <{}>"
                             .format(self.mackup_folder)):
                os.makedirs(self.mackup_folder)
            else:
                utils.error("Mackup can't do anything without a home =(")
549653
def get_home(self, home_id=None):
        
        now = datetime.datetime.utcnow()
        if self.home and now < self.home_refresh_at:
            return self.home

        if not self._do_auth():
            raise RuntimeError("Unable to login")

        if home_id is None:
            home_id = self.home_id

        url = self.api_base_url + "Home/GetHomeById"

        params = {
            "homeId": home_id
        }

        headers = {
            "Accept": "application/json",
            'Authorization':
                'bearer ' + self.login_data['token']['accessToken']
        }

        response = requests.get(
            url, params=params, headers=headers, timeout=10)

        if response.status_code != 200:
            raise RuntimeError(
                "{} response code when getting home".format(
                    response.status_code))

        home = response.json()

        if self.cache_home:
            self.home = home
            self.home_refresh_at = (datetime.datetime.utcnow()
                                    + datetime.timedelta(minutes=5))

        return home
1098189
def copy(self):
        
        state_copy = State()
        state_copy._state_dict = copy.deepcopy(self._state_dict)
        return state_copy
24270
public function home()
    {
        $json = $this->container->json;

        // Get Piton Engine version from composer.lock
        if (null === $definition = $json->getJson(ROOT_DIR . '/composer.lock')) {
            $this->setAlert('danger', 'Error Reading composer.lock', $json->getErrorMessages());
        }

        $engineKey = array_search('pitoncms/engine', array_column($definition->packages, 'name'));
        $engineVersion = $definition->packages[$engineKey]->version;

        return $this->render('home.html', ['pitonEngineVersion' => $engineVersion]);
    }
178412
@RequestMapping(value = "/", method = RequestMethod.GET)
	public String home(Locale locale, Model model) {
		logger.info("Welcome home! The client locale is {}.", locale);
		
		this.setupHomePage(locale, model);
		return "home";
	}
109147
def parent(self):
        
        if not self._meta.parent:
            return None

        if not self.__parent__:
            self.__parent__ = self._meta.parent()

        return self.__parent__
340286
def home_handler(self, config=None, prefix=None, **args):
        
        gresponse = self.google_get_token(config, prefix)
        gdata = self.google_get_data(config, gresponse)
        email = gdata.get('email', 'NO_EMAIL')
        name = gdata.get('name', 'NO_NAME')
        # Make and store cookie from identity, set and close window
        cookie = self.access_cookie(name + ' ' + email)
        return self.set_cookie_close_window_response(cookie)
332344
public function home()
    {
        $home = Grav::instance()['config']->get('system.home.alias');

        return $this->route() === $home || $this->rawRoute() === $home;
    }
1141845
def home_slug():
    
    prefix = get_script_prefix()
    slug = reverse("home")
    if slug.startswith(prefix):
        slug = '/' + slug[len(prefix):]
    try:
        return resolve(slug).kwargs["slug"]
    except KeyError:
        return slug
557292
public function home()
    {
        $page = $this->repository->findPagesByURL('home');

        $view = view('cms-frontend::pages.home');

        if (is_null($page)) {
            return $view;
        }

        return $view->with('page', $page);
    }
270879
def personsAtHome(self, home=None):
        
        if not home: home = self.default_home
        home_data = self.homeByName(home)
        atHome = []
        for p in home_data['persons']:
            #Only check known persons
            if 'pseudo' in p:
                if not p["out_of_sight"]:
                    atHome.append(p['pseudo'])
        return atHome
142248
def get_default_home_dir():
    
    ding0_dir = str(cfg_ding0.get('config',
                                  'config_dir'))
    return os.path.join(os.path.expanduser('~'), ding0_dir)
806290
def home():
    """"""
    return dict(links=dict(api='{}{}'.format(request.url, PREFIX[1:]))), \
        HTTPStatus.OK
926327
def copy(self):
        
        new_prog = self.copy_everything_except_instructions()
        new_prog._instructions = self._instructions.copy()
        return new_prog