Returns a list of all of the sigla for `work`.

        :param work: name of work
        :type work: `str`
        :rtype: `list` of `str`
185879
def get_sigla(self, work):
        
        return [os.path.splitext(os.path.basename(path))[0]
                for path in glob.glob(os.path.join(self._path, work, '*.txt'))]
1057491
def all(opts={})

      res = fetch_all(opts)

      res.is_a?(Array) ? res.map { |hwi| Ruote::Workitem.new(hwi) } : res
    end
31854
def all_notebook_jobs(self):
        
        from db.models.notebooks import NotebookJob

        return NotebookJob.all.filter(project=self)
330329
def get_symbols_list(self):
        ''''''
        slist = []
        rc, nSymb, nElem = gdxcc.gdxSystemInfo(self.gdx_handle)
        assert rc, 'Unable to retrieve "%s" info' % self.filename
        self.number_symbols = nSymb
        self.number_elements = nElem
        slist = [None]*(nSymb+1)
        for j in range(0,nSymb+1):
            sinfo = self.get_sid_info(j)
            if j==0:
                sinfo['name'] = 'universal_set'
            slist[j] = GdxSymb(self,sinfo)
        return slist
58158
def all_tensorboard_jobs(self):
        
        from db.models.tensorboards import TensorboardJob

        return TensorboardJob.all.filter(project=self)
310769
def _get_result_paths(self, data):
        
        assignment_fp = str(self.Parameters['-o'].Value).strip('"')
        if not os.path.isabs(assignment_fp):
            assignment_fp = os.path.relpath(assignment_fp, self.WorkingDir)
        return {'Assignments': ResultPath(assignment_fp, IsWritten=True)}
113814
def statistics(self):
        
        if self._statistics is None:
            self._statistics = WorkersStatisticsList(
                self._version,
                workspace_sid=self._solution['workspace_sid'],
            )
        return self._statistics
121620
def list_work_units(self, work_spec_name, start=0, limit=None):
        
        return self.registry.filter(WORK_UNITS_ + work_spec_name,
                                    start=start, limit=limit)
1182222
def tasks(self):
        
        if self._tasks is None:
            self._tasks = TaskList(self._version, workspace_sid=self._solution['sid'], )
        return self._tasks
892907
def list_task_definitions(self):
        
        task_arns = []
        for task_definition_list in self.task_definitions.values():
            task_arns.extend(
                [task_definition.arn for task_definition in task_definition_list])
        return task_arns
382339
private void collectWorkerInfo(List<WorkerInfo> workerInfoList) {
    initVariables();
    for (WorkerInfo workerInfo : workerInfoList) {
      long usedBytes = workerInfo.getUsedBytes();
      long capacityBytes = workerInfo.getCapacityBytes();
      mSumCapacityBytes += capacityBytes;
      mSumUsedBytes += usedBytes;

      String workerName = workerInfo.getAddress().getHost();

      Map<String, Long> totalBytesOnTiers = workerInfo.getCapacityBytesOnTiers();
      for (Map.Entry<String, Long> totalBytesTier : totalBytesOnTiers.entrySet()) {
        String tier = totalBytesTier.getKey();
        long value = totalBytesTier.getValue();
        mSumCapacityBytesOnTierMap.put(tier,
            value + mSumCapacityBytesOnTierMap.getOrDefault(tier, 0L));

        Map<String, String> map = mCapacityTierInfoMap.getOrDefault(tier, new HashMap<>());
        map.put(workerName, FormatUtils.getSizeFromBytes(value));
        mCapacityTierInfoMap.put(tier, map);
      }

      Map<String, Long> usedBytesOnTiers = workerInfo.getUsedBytesOnTiers();
      for (Map.Entry<String, Long> usedBytesTier: usedBytesOnTiers.entrySet()) {
        String tier = usedBytesTier.getKey();
        long value = usedBytesTier.getValue();
        mSumUsedBytesOnTierMap.put(tier,
            value + mSumUsedBytesOnTierMap.getOrDefault(tier, 0L));

        Map<String, String> map = mUsedTierInfoMap.getOrDefault(tier, new HashMap<>());
        map.put(workerName, FormatUtils.getSizeFromBytes(value));
        mUsedTierInfoMap.put(tier, map);
      }
    }
  }
715822
def get_all_items(self):
        """"""
        for item in os.walk(self.test_case_dir):
            if "workitem.xml" not in item[2]:
                continue
            case_id = os.path.split(item[0])[-1]
            if not (case_id and "*" not in case_id):
                continue
            item_cache = self[case_id]
            if not item_cache:
                continue
            if not item_cache.get("title"):
                continue
            yield item_cache
217411
def get_all_tasks(self, subsystem):
        
        with open(os.path.join(self.per_subsystem[subsystem], 'tasks'), 'r') as tasksFile:
            for line in tasksFile:
                yield int(line)
1251300
def statistics(self):
        
        if self._statistics is None:
            self._statistics = WorkerStatisticsList(
                self._version,
                workspace_sid=self._solution['workspace_sid'],
                worker_sid=self._solution['sid'],
            )
        return self._statistics
123600
def to_dict(self):
        
        return {
            'task_name': self.task_name,
            'dag_name': self.dag_name,
            'workflow_name': self.workflow_name,
            'workflow_id': self.workflow_id,
            'worker_hostname': self.worker_hostname
        }
1026594
def iter_work_specs(self, limit=None, start=None):
        '''
        
        '''
        count = 0
        ws_list, start = self.list_work_specs(limit, start)
        while True:
            for name_spec in ws_list:
                yield name_spec[1]
                count += 1
                if (limit is not None) and (count >= limit):
                    break
            if not start:
                break
            if limit is not None:
                limit -= count
            ws_list, start = self.list_work_specs(limit, start)
81481
def get_works(self):
        
        return [os.path.split(filepath)[1] for filepath in
                glob.glob(os.path.join(self._path, '*'))
                if os.path.isdir(filepath)]