GetProjectResources.
        [Preview API]
        :param str project: Project ID or project name
        :param str type:
        :param str id:
        :rtype: [DefinitionResourceReference]
555221
def get_project_resources(self, project, type=None, id=None):
        
        route_values = {}
        if project is not None:
            route_values['project'] = self._serialize.url('project', project, 'str')
        query_parameters = {}
        if type is not None:
            query_parameters['type'] = self._serialize.query('type', type, 'str')
        if id is not None:
            query_parameters['id'] = self._serialize.query('id', id, 'str')
        response = self._send(http_method='GET',
                              location_id='398c85bc-81aa-4822-947c-a194a05f0fef',
                              version='5.0-preview.1',
                              route_values=route_values,
                              query_parameters=query_parameters)
        return self._deserialize('[DefinitionResourceReference]', self._unwrap_collection(response))
642173
def get_updates(self, id, project=None, top=None, skip=None):
        
        route_values = {}
        if project is not None:
            route_values['project'] = self._serialize.url('project', project, 'str')
        if id is not None:
            route_values['id'] = self._serialize.url('id', id, 'int')
        query_parameters = {}
        if top is not None:
            query_parameters['$top'] = self._serialize.query('top', top, 'int')
        if skip is not None:
            query_parameters['$skip'] = self._serialize.query('skip', skip, 'int')
        response = self._send(http_method='GET',
                              location_id='6570bf97-d02c-4a91-8d93-3abe9895b1a9',
                              version='5.1-preview.3',
                              route_values=route_values,
                              query_parameters=query_parameters)
        return self._deserialize('[WorkItemUpdate]', self._unwrap_collection(response))
42786
def get_project(self, project_id):
        ''''''
        project_response = self.get_request('projects/%s' % project_id)
        return Project(self, project_response['project'])
394265
def project_stored_info_type_path(cls, project, stored_info_type):
        """"""
        return google.api_core.path_template.expand(
            "projects/{project}/storedInfoTypes/{stored_info_type}",
            project=project,
            stored_info_type=stored_info_type,
        )
1238884
def get_project_export(self, project_id):
        
        try:
            result = self._request('/getprojectexport/',
                                   {'projectid': project_id})
            return TildaProject(**result)
        except NetworkError:
            return []
76764
def create_resources(self, creation_parameters, project):
        
        route_values = {}
        if project is not None:
            route_values['project'] = self._serialize.url('project', project, 'str')
        content = self._serialize.body(creation_parameters, '{ResourceCreationParameter}')
        response = self._send(http_method='POST',
                              location_id='43201899-7690-4870-9c79-ab69605f21ed',
                              version='5.1-preview.1',
                              route_values=route_values,
                              content=content)
        return self._deserialize('CreatedResources', response)
523434
def get_project() -> Optional[str]:
    
    project = SETTINGS.project
    if not project:
        require_test_mode_enabled()
        raise RunError('Missing project name; for test mode, please set PULUMI_NODEJS_PROJECT')
    return project
874962
def get_preview_url(resource):
    '''
    
    '''
    candidates = (p.preview_url(resource)
                  for p in get_enabled_plugins()
                  if p.can_preview(resource))
    return next(iter(candidates), None)
784235
def projects(self, task, params={}, **options): 
        
        path = "/tasks/%s/projects" % (task)
        return self.client.get_collection(path, params, **options)
1311584
def get_pipeline(self, project, pipeline_id, revision=None):
        
        route_values = {}
        if project is not None:
            route_values['project'] = self._serialize.url('project', project, 'str')
        if pipeline_id is not None:
            route_values['pipelineId'] = self._serialize.url('pipeline_id', pipeline_id, 'int')
        query_parameters = {}
        if revision is not None:
            query_parameters['revision'] = self._serialize.query('revision', revision, 'int')
        response = self._send(http_method='GET',
                              location_id='28e1305e-2afe-47bf-abaf-cbb0e6a91988',
                              version='5.1-preview.1',
                              route_values=route_values,
                              query_parameters=query_parameters)
        return self._deserialize('Pipeline', response)
159194
@RequestMapping(value = "{entityType}/{id}", method = RequestMethod.GET)
    public Resources<Resource<Property<?>>> getProperties(@PathVariable ProjectEntityType entityType, @PathVariable ID id) {
        ProjectEntity entity = getEntity(entityType, id);
        List<Property<?>> properties = propertyService.getProperties(entity);
        List<Resource<Property<?>>> resources = new ArrayList<>();
        for (Property<?> property : properties) {
            Resource<Property<?>> resource = Resource.of(
                    property,
                    uri(on(getClass()).getPropertyValue(entity.getProjectEntityType(), entity.getId(), property.getType().getClass().getName()))
            );
            // Update
            resource = resource.with(
                    Link.UPDATE,
                    uri(on(getClass()).getPropertyEditionForm(entity.getProjectEntityType(), entity.getId(), property.getType().getClass().getName())));
            // OK
            resources.add(resource);
        }
        return Resources.of(
                resources,
                uri(on(getClass()).getProperties(entityType, id))
        );
    }
306672
def describe_export(self, export_type):
        
        if export_type in TALK_EXPORT_TYPES:
            return talk.get_data_request(
                'project-{}'.format(self.id),
                export_type.replace('talk_', '')
            )[0]

        return self.http_get(
            self._export_path(export_type),
        )[0]
20683
public List<JavaResource> getProjectInjectionPointBeans(Project project)
   {
      final List<JavaResource> beans = new ArrayList<>();
      if (project != null)
      {
         project.getFacet(JavaSourceFacet.class).visitJavaSources(new JavaResourceVisitor()
         {
            @Override
            public void visit(VisitContext context, JavaResource resource)
            {
               try
               {
                  JavaSource<?> javaSource = resource.getJavaType();
                  if (javaSource.isClass()
                           // JPA
                           && !javaSource.hasAnnotation(Entity.class)
                           && !javaSource.hasAnnotation(MappedSuperclass.class)
                           && !javaSource.hasAnnotation(Embeddable.class)
                           // Bean Validation
                           && !javaSource.hasImport(Payload.class)
                  )
                  {
                     beans.add(resource);
                  }
               }
               catch (FileNotFoundException e)
               {
                  // ignore
               }
            }
         });
      }
      return beans;
   }
864205
def get_project(self, project_short_name):
        """"""
        project = pbclient.find_project(short_name=project_short_name,
                                        all=self.all)
        if (len(project) == 1):
            return project[0]
        else:
            raise ProjectNotFound(project_short_name)
354603
private void readResources(Project plannerProject) throws MPXJException
   {
      Resources resources = plannerProject.getResources();
      if (resources != null)
      {
         for (net.sf.mpxj.planner.schema.Resource res : resources.getResource())
         {
            readResource(res);
         }
      }
   }
633262
def get_projects():
    
    assert request.method == "GET", "GET request expected received {}".format(request.method)
    try:
        if request.method == 'GET':
            projects = utils.get_projects()

            return jsonify(projects)
    except Exception as e:
        logging.error(e)
    return jsonify({"0": "__EMPTY"})
200241
public List<JavaResource> getProjectInjectableBeans(Project project)
   {
      final List<JavaResource> beans = new ArrayList<>();
      if (project != null)
      {
         project.getFacet(JavaSourceFacet.class).visitJavaSources(new JavaResourceVisitor()
         {
            @Override
            public void visit(VisitContext context, JavaResource resource)
            {
               try
               {
                  JavaSource<?> javaSource = resource.getJavaType();
                  if (!javaSource.isAnnotation() && !javaSource.isEnum()
                           // CDI
                           && !javaSource.hasAnnotation(Decorator.class)
                           && !javaSource.hasAnnotation(Interceptor.class)
                           // EJB
                           && !javaSource.hasAnnotation(MessageDriven.class)
                           // JPA
                           && !javaSource.hasAnnotation(Entity.class)
                           && !javaSource.hasAnnotation(Embeddable.class)
                           && !javaSource.hasAnnotation(MappedSuperclass.class)
                           // JSF
                           && !javaSource.hasAnnotation(FacesConverter.class)
                           && !javaSource.hasAnnotation(FacesValidator.class)
                           // REST
                           && !javaSource.hasAnnotation(Path.class)
                           // Servlet
                           && !javaSource.hasAnnotation(WebServlet.class)
                           && !javaSource.hasAnnotation(WebFilter.class)
                           && !javaSource.hasAnnotation(WebListener.class)
                           // Bean Validation
                           && !javaSource.hasImport(ConstraintValidator.class)
                           && !javaSource.hasImport(Payload.class)
                  )
                  {
                     beans.add(resource);
                  }
               }
               catch (ResourceException | FileNotFoundException e)
               {
                  // ignore
               }
            }
         });
      }
      return beans;
   }