Set the location of the feed - loc must be an EEML::Location object
559290
def location=(loc)
      unless loc.is_a?(EEML::Location)
        raise TypeError.new('loc must be an EEML::Location') 
      end
      @location = loc
    end
915576
def location(self, x=None, y=None):
        ''' 
        '''
        stream = self._stream
        stream.write(self.save_pos)  # cursor position

        if x is not None and y is not None:
            stream.write(self.mv(y, x))
        elif x is not None:
            stream.write(self.mv_x(x))
        elif y is not None:
            stream.write(self.mv_y(y))

        stream.flush()
        try:
            yield self
        finally:
            stream.write(self.rest_pos)
            stream.flush()
474852
def set_location(self, latitude, longitude, altitude=10):
        
        driver = self._current_application()
        driver.set_location(latitude,longitude,altitude)
169243
def set_location(self, obj, cursor):
        
        if (hasattr(cursor, 'location') and cursor.location is not None and
                cursor.location.file is not None):
            obj.location = (cursor.location.file.name, cursor.location.line)
        return
789664
public void setLat(final int LAT_DEG, final double LAT_MIN) {
        this.lat = convert(LAT_DEG, LAT_MIN);
        this.LOCATION.setLocation(this.lat, this.lon);
        adjustDirection();
    }
161849
def set_legend_location(self, loc, onaxis):
        ""
        self.legend_onaxis = 'on plot'
        if not onaxis:
            self.legend_onaxis = 'off plot'
            if loc == 'best':
                loc = 'upper right'
        if loc in self.legend_abbrevs:
            loc = self.legend_abbrevs[loc]
        if loc in self.legend_locs:
            self.legend_loc = loc
1349346
def location(self):
        """"""
        if self._w3c:
            old_loc = self._execute(Command.GET_ELEMENT_RECT)['value']
        else:
            old_loc = self._execute(Command.GET_ELEMENT_LOCATION)['value']
        new_loc = {"x": round(old_loc['x']),
                   "y": round(old_loc['y'])}
        return new_loc
183439
private function configureSourceLocale()
    {
        $em = $this->app->make(EntityManager::class);
        /* @var EntityManager $em */
        $repo = $this->app->make(LocaleRepository::class);
        if ($repo->findOneBy(['isSource' => true]) === null) {
            $locale = LocaleEntity::create('en_US');
            $locale
                ->setIsApproved(true)
                ->setIsSource(true)
            ;
            $em->persist($locale);
            $em->flush($locale);
        }
    }
764091
def action_update_library_location(_location):
    

    # if not(os.path.exists(_location)):
    # 	os.mkdir(_location)
    # 	printDebug("Creating new folder..", "comment")

    printDebug("Old location: '%s'" % get_home_location(), "comment")

    if os.path.isdir(_location):

        config = SafeConfigParser()
        config_filename = ONTOSPY_LOCAL + '/config.ini'
        config.read(config_filename)
        if not config.has_section('models'):
            config.add_section('models')

        config.set('models', 'dir', _location)
        with open(config_filename, 'w') as f:
            config.write(
                f)  # note: this does not remove previously saved settings

        return _location
    else:
        return None
432381
def update_location(self, ps):
        """"""

        loc = ps.get('location')
        if not loc:
            loc = os.path.join(self.project().get('location'), self.name())
            ps = ps.add_raw(["<location>" + loc])

        return ps
879047
def set_data_location(apps, schema_editor):
    """"""
    Data = apps.get_model('flow', 'Data')
    DataLocation = apps.get_model('flow', 'DataLocation')

    for data in Data.objects.all():
        if os.path.isdir(os.path.join(settings.FLOW_EXECUTOR['DATA_DIR'], str(data.id))):
            with transaction.atomic():
                # Manually set DataLocation id to preserve data directory.
                data_location = DataLocation.objects.create(id=data.id, subpath=str(data.id))
                data_location.data.add(data)

    # Increment DataLocation id's sequence
    if DataLocation.objects.exists():
        max_id = DataLocation.objects.order_by('id').last().id
        with connection.cursor() as cursor:
            cursor.execute(
                "ALTER SEQUENCE flow_datalocation_id_seq RESTART WITH {};".format(max_id + 1)
            )
1369391
def thing2place(self, name):
        """"""
        self.engine._set_thing_loc(
            self.name, name, None
        )
        if (self.name, name) in self.engine._node_objs:
            thing = self.engine._node_objs[self.name, name]
            place = Place(self, name)
            for port in thing.portals():
                port.origin = place
            for port in thing.preportals():
                port.destination = place
            self.engine._node_objs[self.name, name] = place
1372894
function getLocation(template, loc){
  if (loc)
    return (template.sourceUrl || '') + ':' + loc.start.line + ':' + (loc.start.column + 1);
}
937879
private void assignLocation(PhysicalEntity pe, Glyph g) {
		// Create compartment -- add this inside the compartment
		Glyph loc = getCompartment(pe);
		if (loc != null) {
			g.setCompartmentRef(loc);
		}
	}
1009185
def _solve_location(self, req, dut_req_len, idx):
        
        if not req.get("location"):
            return
        if len(req.get("location")) == 2:
            for x_and_y, coord in enumerate(req.get("location")):

                if isinstance(coord, string_types):
                    coord = ResourceConfig.__replace_coord_variables(coord,
                                                                     x_and_y,
                                                                     dut_req_len,
                                                                     idx)
                    try:
                        loc = req.get("location")
                        loc[x_and_y] = eval(coord)  # pylint: disable=eval-used
                        req.set("location", loc)
                    except SyntaxError as error:
                        self.logger.error(error)
                        loc = req.get("location")
                        loc[x_and_y] = 0.0
                        req.set("location", loc)
        else:
            self.logger.error("invalid location field!")
            req.set("location", [0.0, 0.0])
1145018
def update_extent_location(self, extent_loc):
        # type: (int) -> None
        '''
        
        '''
        if not self._initialized:
            raise pycdlibexception.PyCdlibInternalError('Path Table Record not yet initialized')

        self.extent_location = extent_loc
106580
def seek(self, loc):
        """"""
        assert loc == 0

        # rewind progress bar
        if self.progressbar:
            self.progressbar.update(-self._tell)

        self._fp_left.seek(loc)
        self._fp_right.seek(loc)
        self._tell = loc
        self._buf = Buffer()