Returns a list of fixed stars.
339549
def getFixedStarList(IDs, date):
    
    starList = [getFixedStar(ID, date) for ID in IDs]
    return FixedStarList(starList)
1362945
def has_in_starred(self, starred):
        
        assert isinstance(starred, github.Repository.Repository), starred
        status, headers, data = self._requester.requestJson(
            "GET",
            "/user/starred/" + starred._identity
        )
        return status == 204
954556
function buildStars(numVerts, cells) {
  var stars = new Array(numVerts)
  for(var i=0; i<numVerts; ++i) {
    stars[i] = []
  }
  var numCells = cells.length
  for(var i=0; i<numCells; ++i) {
    var f = cells[i]
    for(var j=0; j<3; ++j) {
      stars[f[j]].push(i)
    }
  }
  return stars
}
422536
def _plot_stars(catalog, observer, project, ax, mag1, mag2, margin=1.25):
    """"""

    art = []

    # from astropy import wcs
    # w = wcs.WCS(naxis=2)
    # w.wcs.crpix = [-234.75, 8.3393]
    # w.wcs.cdelt = np.array([-0.066667, 0.066667])
    # w.wcs.crval = [0, -90]
    # w.wcs.ctype = ["RA---AIR", "DEC--AIR"]
    # w.wcs.set_pv([(2, 1, 45.0)])

    # import matplotlib.pyplot as plt

    # plt.subplot(projection=wcs)
    # #plt.imshow(hdu.data, vmin=-2.e-5, vmax=2.e-4, origin='lower')
    # plt.grid(color='white', ls='solid')
    # plt.xlabel('Galactic Longitude')
    # plt.ylabel('Galactic Latitude')

    xmin, xmax = ax.get_xlim()
    ymin, ymax = ax.get_xlim()
    lim = max(abs(xmin), abs(xmax), abs(ymin), abs(ymax)) * margin
    lims = (-lim, lim)
    ax.set_xlim(lims)
    ax.set_ylim(lims)
    ax.set_aspect('equal')

    o = observer[0]

    # Dim stars: points of with varying gray levels.

    c = catalog
    c = c[c['magnitude'] > mag1]
    c = c[c['magnitude'] <= mag2]
    #print('Second star group:', len(c))
    c = c.sort_values('magnitude', ascending=False)
    s = Star(ra_hours=c.ra_hours, dec_degrees=c.dec_degrees)
    spos = o.observe(s)
    x, y = project(spos)
    m = (mag2 - c['magnitude']) / (mag2 - mag1)
    # Note that "gray_r" is white for 0.0 and black for 1.0
    art.append(ax.scatter(
        x, y, s=1.0,
        c=1 - 0.8 * m, cmap='gray_r', vmin=0.0, vmax=1.0,
    ))

    # Bright stars: black circles of varying radius, surrounded by a
    # white gap in case stars are touching.  Draw the brightest stars
    # first to stop them from completely occluding smaller companions.

    def mag_to_radius(m):
        return (mag1 - m) * scale + 1.0

    c = catalog
    c = c[c['magnitude'] <= mag1]
    c = c.sort_values('magnitude', ascending=True)
    #print('First star group:', len(c))
    s = Star(ra_hours=c.ra_hours, dec_degrees=c.dec_degrees)
    spos = o.observe(s)
    x, y = project(spos)
    scale = 1.5
    radius = mag_to_radius(c['magnitude'])

    x2 = np.repeat(x, 2)
    y2 = np.repeat(y, 2)
    radius2 = (radius[:,None] + (3.0,0.0)).flatten()
    c2 = ('w', 'k')
    c2 = ('k', 'w')

    art.append(ax.scatter(x2, y2, s=radius2 ** 2.0, c=c2))

    return art, mag_to_radius
646293
def loadings(self):
        """"""
        loadings = self.v[:, : self.keep] * np.sqrt(self.eigenvalues)
        cols = ["PC%s" % i for i in range(1, self.keep + 1)]
        loadings = pd.DataFrame(
            loadings, columns=cols, index=self.feature_names
        )
        return loadings
171496
def select_star_cb(self, widget, res_dict):
        
        keys = list(res_dict.keys())
        if len(keys) == 0:
            self.selected = []
            self.replot_stars()
        else:
            idx = int(keys[0])
            star = self.starlist[idx]
            if not self._select_flag:
                self.mark_selection(star, fromtable=True)
        return True
564805
def get_star(self, component=None, **kwargs):
        
        kwargs.setdefault('kind', 'star')
        return self.get_component(component, **kwargs)
525249
def NamedStar(name):
    """"""
    try:
        hid = named_star_dict[name]
        return hipparcos.get(str(hid))
    except KeyError:
        raise ValueError("No star named {0} known to skyfield.".format(name))
908594
def getModifiers(chart):
    
    
    modifiers = []
    
    # Factors which can be affected
    asc = chart.getAngle(const.ASC)
    ascRulerID = essential.ruler(asc.sign)
    ascRuler = chart.getObject(ascRulerID)
    moon = chart.getObject(const.MOON)
    factors = [
        [MOD_ASC, asc],
        [MOD_ASC_RULER, ascRuler],
        [MOD_MOON, moon]
    ]
    
    # Factors of affliction
    mars = chart.getObject(const.MARS)
    saturn = chart.getObject(const.SATURN)
    sun = chart.getObject(const.SUN)
    affect = [
        [mars, [0, 90, 180]],
        [saturn, [0, 90, 180]],
        [sun, [0]]     
    ]
    
    # Do calculations of afflictions
    for affectingObj, affectingAsps in affect:
        for factor, affectedObj in factors:
            modf = modifierFactor(chart, 
                                  factor, 
                                  affectedObj, 
                                  affectingObj, 
                                  affectingAsps)
            if modf:
                modifiers.append(modf)
    
    return modifiers
364183
def process_star(filename, output, *, extension, star_name, period, shift,
                 parameters, period_label, shift_label, **kwargs):
    
    if star_name is None:
        basename = path.basename(filename)
        if basename.endswith(extension):
            star_name = basename[:-len(extension)]
        else:
            # file has wrong extension
            return
    if parameters is not None:
        if period is None:
            try:
                period = parameters[period_label][star_name]
            except KeyError:
                pass
            if shift is None:
                try:
                    shift = parameters.loc[shift_label][star_name]
                except KeyError:
                    pass

    result = get_lightcurve_from_file(filename, name=star_name,
                                      period=period, shift=shift,
                                      **kwargs)
    if result is None:
        return
    if output is not None:
        plot_lightcurve(star_name, result['lightcurve'], result['period'],
                        result['phased_data'], output=output, **kwargs)

    return result
437490
def star_points(point, options)
      x, y = point
      radius = options[:radius]
      y = y + radius * 0.05
      points = []
      points << [x,                 y + radius * 0.9]
      points << [x + 0.25 * radius, y + 0.2 * radius]
      points << [x + radius,        y + 0.2 * radius]
      points << [x + 0.4 * radius,  y - 0.2 * radius]
      points << [x + 0.7 * radius,  y - 1.0 * radius]
      points << [x,                 y - 0.5 * radius]
      points << [x - 0.7 * radius,  y - 1.0 * radius]
      points << [x - 0.4 * radius,  y - 0.2 * radius]
      points << [x - radius,        y + 0.2 * radius]
      points << [x - 0.25 * radius, y + 0.2 * radius]
      points
    end
613453
def fits_list(filter,root,fnames):
    """"""
    import re, pyfits, wcsutil
    for file in fnames:
        if re.match(filter,file):
            fh=pyfits.open(file)
            for ext in fh:
                obj=ext.header.get('OBJECT',file)
                dx=ext.header.get('NAXIS1',None)
                dy=ext.header.get('NAXIS2',None)
                wcs=wcsutil.WCSObject(ext)
                (x1,y1)=wcs.xy2rd((1,1,))
                (x2,y2)=wcs.xy2rd((dx,dy))
                ccds=[x1,y1,x2,y2]
                pointing={'label': obj, 'camera': ccds}
    return files
204294
def Nstars(self):
        
        if self._Nstars is None:
            N = {}
            for n in self.get_model_nodes():
                if n.index not in N:
                    N[n.index] = 1
                else:
                    N[n.index] += 1
            self._Nstars = N
        return self._Nstars
645992
def get_starred(self):
        
        return github.PaginatedList.PaginatedList(
            github.Repository.Repository,
            self._requester,
            "/user/starred",
            None
        )
184313
def all_good_stars(self):
        

        stars = []
        for star in self.all_stars:
            if star._excluded_from_fit:
                continue
            else:
                stars.append(star)

        return stars
1107966
def visit_starred(self, node, parent):
        """"""
        context = self._get_context(node)
        newnode = nodes.Starred(
            ctx=context, lineno=node.lineno, col_offset=node.col_offset, parent=parent
        )
        newnode.postinit(self.visit(node.value, newnode))
        return newnode
1034171
def a_star_search(graph, start, goal):
    
    all_nodes = graph.get_all_node_ids()
    if start not in all_nodes:
        raise NonexistentNodeError(start)
    if goal not in all_nodes:
        raise NonexistentNodeError(goal)

    came_from, cost_so_far, goal_reached = _a_star_search_internal(graph, start, goal)
    if goal_reached:
        path = reconstruct_path(came_from, start, goal)
        path.reverse()
        return path
    else:
        return []