Returns the compact records for all sections in the specified project.

        Parameters
        ----------
        project : {Id} The project to get sections from.
        [params] : {Object} Parameters for the request
427124
def find_by_project(self, project, params={}, **options): 
        
        path = "/projects/%s/sections" % (project)
        return self.client.get(path, params, **options)
604779
def get_project(id=None, name=None):
    
    content = get_project_raw(id, name)
    if content:
        return utils.format_json(content)
287773
def get_imports(self, volume=None, state=None, offset=None, limit=None):
        
        return self._api.imports.query(project=self.id, volume=volume,
                                       state=state, offset=offset, limit=limit)
44872
def get_project(self, project_id):
        
        try:
            return self._projects[project_id]
        except KeyError:
            raise aiohttp.web.HTTPNotFound(text="Project ID {} doesn't exist".format(project_id))
899294
function getSharedProjects(req, res, callback) {
        var projects = [];
        userProjects.getUserSharedProjects(req.user.username)
        .then(function(sharedProjects) {
            function add(lst) {
                lst.forEach(function(project) {
                    //update the name of the project to include the original owner's username,
                    //so that projects with the same name can be differentiated.
                    project.Name = project.Name + " (" + project.Location.split(path.sep)[2] + "'s workspace)";
                    projects.push(project);
                    if (project.Children) add(project.Children);
                });
            }
            if (sharedProjects) {
	            add(sharedProjects);
            }
            callback(projects);
        });
    }
521269
def get_apps(self, offset=None, limit=None):
        
        params = {'project': self.id, 'offset': offset,
                  'limit': limit}
        return self._api.apps.query(api=self._api, **params)
741509
def get_segment_projects(segment_id):
    
    df = data.all_items
    return (
        df[df['idSegmento'] == str(segment_id)]
        .drop_duplicates(["PRONAC"])
        .values
    )
784235
def projects(self, task, params={}, **options): 
        
        path = "/tasks/%s/projects" % (task)
        return self.client.get_collection(path, params, **options)
138918
function getRecentProjects() {
        var recentProjects = PreferencesManager.getViewState("recentProjects") || [],
            i;

        for (i = 0; i < recentProjects.length; i++) {
            // We have to canonicalize & then de-canonicalize the path here, since our pref format uses no trailing "/"
            recentProjects[i] = FileUtils.stripTrailingSlash(ProjectManager.updateWelcomeProjectPath(recentProjects[i] + "/"));
        }
        return recentProjects;
    }
569169
def get_loaded_project(self, project_id):
        
        project = self.get_project(project_id)
        yield from project.wait_loaded()
        return project
889053
function list(req, res, next) {
  forms.getAllAppForms(req.connectionOptions, formsResultHandlers(constants.resultTypes.formProjects, req, next));
}
650692
def get_sections_for_course(id, opts = {})
      data, _status_code, _headers = get_sections_for_course_with_http_info(id, opts)
      return data
    end
482069
def find_by_id(self, project, params={}, **options): 
        
        path = "/projects/%s" % (project)
        return self.client.get(path, params, **options)
1102171
def get_project(project_id, include_deleted_networks=False, **kwargs):
    
    user_id = kwargs.get('user_id')
    proj_i = _get_project(project_id)

    #lazy load owners
    proj_i.owners

    proj_i.check_read_permission(user_id)

    proj_j = JSONObject(proj_i)

    proj_j.networks = []
    for net_i in proj_i.networks:
        #lazy load owners
        net_i.owners
        net_i.scenarios

        if include_deleted_networks==False and net_i.status.lower() == 'x':
            continue

        can_read_network = net_i.check_read_permission(user_id, do_raise=False)
        if can_read_network is False:
            continue

        net_j = JSONObject(net_i)
        proj_j.networks.append(net_j)

    return proj_j
650879
def org_find_projects(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/findProjects' % object_id, input_params, always_retry=always_retry, **kwargs)
712102
function getFormIds(req, res, next) {
  var params = {
    appId: req.params.projectid || req.params.id
  };

  forms.getAppFormsForApp(_.extend(req.connectionOptions, params), function(err, appFormResult) {
    if (err) {
      return next(err);
    }

    //Only Want The Form Ids
    req.appformsResultPayload = {
      data: _.map(_.compact(appFormResult.forms), function(form) {
        return form._id.toString();
      }),
      type: constants.resultTypes.formProjects
    };

    next();
  });
}
5371
def get_listed_projects():
    
    index_path = Path().resolve() / "docs" / "index.md"
    with open(index_path, "r") as index_file:
        lines = index_file.readlines()

    listed_projects = set()
    project_section = False
    for _, l in enumerate(lines):
        idx = l.find(PROJECT_KEY)
        if idx >= 0:
            project_section = True
        if project_section:
            # Find first parenthesis after the key
            start = l.find("](")
            if start > 0:
                closing_parenthesis = sorted(
                    [m.start() for m in re.finditer(r"\)", l) if m.start() > start]
                )[0]
                project = l[start + 2 : closing_parenthesis]
                listed_projects.add(project)
        # If the Projects section is over, stop iteration.
        # It will stop before seeing ## but wainting for it
        # Allows the user to use single # in the projects' descriptions
        if len(listed_projects) > 0 and l.startswith("#"):
            return listed_projects
    return listed_projects