Return the total points possible for this project.
771186
def points_possible(self, include_hidden=False):
        """"""
        return sum([test_case.points for testable in self.testables
                    for test_case in testable.test_cases
                    if include_hidden or not testable.is_hidden])
1318716
def calculate_set_values(self):
        
        for ac in self.asset_classes:
            ac.alloc_value = self.total_amount * ac.allocation / Decimal(100)
1135654
def _get_point_value(self, loglstar):
        """"""

        # If the queue is empty, refill it.
        if self.nqueue <= 0:
            self._fill_queue(loglstar)

        # Grab the earliest entry.
        u, v, logl, nc, blob = self.queue.pop(0)
        self.used += 1  # add to the total number of used points
        self.nqueue -= 1

        return u, v, logl, nc, blob
846252
def _get_points(self):
        
        return tuple([self._getitem__points(i)
                     for i in range(self._len__points())])
124769
def total_cycles(self) -> int:
        """"""
        return sum((int(re.sub(r'\D', '', op)) for op in self.tokens))
1109987
def LengthMeters(self):
    """"""
    assert(len(self._points) > 0)
    length = 0
    for i in range(0, len(self._points) - 1):
      length += self._points[i].GetDistanceMeters(self._points[i+1])
    return length
190845
def overall( self, node ):
        """"""
        return sum( [self.value(value,node) for value in self.children(node)] )
867203
def get_project_members(self):
        """"""

        r = self._request('members/')
        if not r:
            return None

        retour = []

        for data in r.json()['members']:
            # Base properties
            u = User()
            u.__dict__.update(data)

            retour.append(u)

        return retour
861797
function () {
      var total = this.stats.length
      return this.stats.map(function (stat, i) {
        var point = valueToPoint(stat.value, i, total)
        return point.x + ',' + point.y
      }).join(' ')
    }
403211
def points(self):
        
        if not self._points:
            self._points = MetricPoints(self.api_client)
        return self._points
865409
def points(self):
        
        vtk_data = self.GetPoints().GetData()
        arr = vtk_to_numpy(vtk_data)
        return vtki_ndarray(arr, vtk_data)
1197391
def preprocess_points(points, preprocessor):
  """"""
  try:
    points = preprocessor(points)
  except Exception as e:
    raise PreprocessorError(e)
  return points
826229
public int getNumPoints() {
		if (isEmpty()) {
			return 0;
		}
		int total = 0;
		for (Polygon polygon : polygons) {
			total += polygon.getNumPoints();
		}
		return total;
	}
71641
public PointList calcPoints() {
        final PointList points = new PointList(edgeIds.size() + 1, nodeAccess.is3D());
        if (edgeIds.isEmpty()) {
            if (isFound()) {
                points.add(graph.getNodeAccess(), endNode);
            }
            return points;
        }

        int tmpNode = getFromNode();
        points.add(nodeAccess, tmpNode);
        forEveryEdge(new EdgeVisitor() {
            @Override
            public void next(EdgeIteratorState eb, int index, int prevEdgeId) {
                PointList pl = eb.fetchWayGeometry(2);
                for (int j = 0; j < pl.getSize(); j++) {
                    points.add(pl, j);
                }
            }

            @Override
            public void finish() {

            }
        });
        return points;
    }
296913
def project_list(self, limit=None):
        
        params = {}
        if limit:
            params['limit'] = limit
        return (self.get('rest/api/1.0/projects', params=params) or {}).get('values')
54670
def score(self):
        
        if not self.scoreProperties:
            self.scoreProperties = self.getScoreProperties()
        return sum(self.scoreProperties.values())
1048494
def p(self, type):
        """"""
        if self.dovalidation: type = self._validate(type)
        return self._count[type] / float(self.total)