Get an instance to read information from Microsoft planner
432144
def planner(self, *, resource=''):
        

        if not isinstance(self.protocol, MSGraphProtocol):
            # TODO: Custom protocol accessing OneDrive/Sharepoint Api fails here
            raise RuntimeError(
                'planner api only works on Microsoft Graph API')

        return Planner(parent=self, main_resource=resource)
613235
def get_info(self, item, check_not_on_or_after=True):
        
        try:
            (timestamp, info) = item
        except ValueError:
            raise ToOld()

        if check_not_on_or_after and not time_util.not_on_or_after(timestamp):
            raise ToOld()

        return info or None
1337954
function getInfo() {
				var collection = mRegistry[collectionName];
				var info = collection && collection[iconName];

				// convert raw data lazily to the icon info
				if (typeof info === 'number') {
					mRegistry[collectionName][iconName] = undefined; // avoid duplicate icon warning
					info = IconPool.addIcon(iconName, collectionName, {
						fontFamily: mFontRegistry[collectionName].config.fontFamily,
						content: info & 0xFFFF,
						suppressMirroring: !!(info & 0x10000),
						resourceBundle: getCoreResourceBundle()
					});
				}

				return info;
			}
829243
def MI_getInstance(self,
                       env,
                       instanceName,
                       propertyList):
        # pylint: disable=invalid-name
        

        logger = env.get_logger()
        logger.log_debug('CIMProvider2 MI_getInstance called...')
        plist = None
        if propertyList is not None:
            plist = [s.lower() for s in propertyList]
            plist += [s.lower() for s in instanceName.keybindings.keys()]
        model = pywbem.CIMInstance(classname=instanceName.classname,
                                   path=instanceName, property_list=plist)
        model.update(model.path.keybindings)

        rval = self.get_instance(env=env, model=model)
        logger.log_debug('CIMProvider2 MI_getInstance returning')
        if rval is None:
            raise pywbem.CIMError(pywbem.CIM_ERR_NOT_FOUND, "")
        return rval
106741
def get_instance(self, payload):
        
        return TaskInstance(self._version, payload, workspace_sid=self._solution['workspace_sid'], )
651250
def _get_instance(self, **kwargs):
        """"""
        current_app.logger.info("Getting instance")
        current_app.logger.debug("kwargs: {}".format(kwargs))

        current_app.logger.info(
            "Loading instance: {}".format(kwargs['obj_id']))
        rec = self.db_query.get_instance(self.db_collection, kwargs['obj_id'])
        g._resource_instance = rec
        current_app.logger.debug(
            "g._resource_instance: {}".format(g._resource_instance))
        return rec
616572
def get_manual(self, start, end):
        """"""
        url = build_url(self.api_key, self.spot_id, self.fields,
                        self.unit, start, end)
        return get_msw(url)
118688
def _get_mapper_params(self):
    """"""
    reader_params = self.input_reader_cls.params_to_json(
        self.input_reader_params)
    # TODO(user): Do the same for writer params.
    return {"input_reader": reader_params,
            "output_writer": self.output_writer_params}
175461
def get_plan_id(kwargs=None, call=None):
    '''
    
    '''
    if call == 'action':
        raise SaltCloudException(
            'The show_instance action must be called with -f or --function.'
        )

    if kwargs is None:
        kwargs = {}

    label = kwargs.get('label', None)
    if label is None:
        raise SaltCloudException(
            'The get_plan_id function requires a \'label\'.'
        )

    label = _decode_linode_plan_label(label)

    return label
145101
def instance_get(plugin, opts, url_file_input, out):
    
    inst = plugin()
    hp, func, enabled_func = inst._general_init(opts, out)
    name = inst._meta.label

    kwargs = {
        'hide_progressbar': hp,
        'functionality': func,
        'enabled_functionality': enabled_func
    }

    if url_file_input:
        del kwargs['hide_progressbar']

    return {
        'inst': inst,
        'kwargs': kwargs
    }
898137
private void readTasks(Project plannerProject) throws MPXJException
   {
      Tasks tasks = plannerProject.getTasks();
      if (tasks != null)
      {
         for (net.sf.mpxj.planner.schema.Task task : tasks.getTask())
         {
            readTask(null, task);
         }

         for (net.sf.mpxj.planner.schema.Task task : tasks.getTask())
         {
            readPredecessors(task);
         }
      }

      m_projectFile.updateStructure();
   }
1031743
def readInfoElement(self, infoElement, instanceObject):
        
        infoLocation = self.locationFromElement(infoElement)
        instanceObject.addInfo(infoLocation, copySourceName=self.infoSource)
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);
         }
      }
   }
1170220
def get_document(project_id, knowledge_base_id, document_id):
    """"""
    import dialogflow_v2beta1 as dialogflow
    client = dialogflow.DocumentsClient()
    document_path = client.document_path(project_id, knowledge_base_id,
                                         document_id)

    response = client.get_document(document_path)
    print('Got Document:')
    print(' - Display Name: {}'.format(response.display_name))
    print(' - Knowledge ID: {}'.format(response.name))
    print(' - MIME Type: {}'.format(response.mime_type))
    print(' - Knowledge Types:')
    for knowledge_type in response.knowledge_types:
        print('    - {}'.format(KNOWLEDGE_TYPES[knowledge_type]))
    print(' - Source: {}\n'.format(response.content_uri))
911726
def get_worksheet(self, id_or_name):
        
        url = self.build_url(self._endpoints.get('get_worksheet').format(id=quote(id_or_name)))
        response = self.session.get(url)
        if not response:
            return None
        return self.worksheet_constructor(parent=self, **{self._cloud_data_key: response.json()})
1132836
def get(self, CachableItem):
        """"""
        cached_item = self.mapper.get(CachableItem)
        r = self.request('get',
            self.url+"storage/collections/data/"+self.collname+'/'+cached_item.getId(),
            data={'output_mode': 'json'})
        if r.ok:
            # we need to update the object with the values found in the cache area
            data = r.json()
            for name in self.mapper.mapper:
                setattr(cached_item, name, data[name])
            return cached_item
        return None
814830
def get_instance(page_to_consume):
    """"""
    global _instances
    if isinstance(page_to_consume, basestring):
        uri = page_to_consume
        page_to_consume = consumepage.get_instance(uri)
    elif isinstance(page_to_consume, consumepage.ConsumePage):
        uri = page_to_consume.uri
    else:
        raise TypeError(
            "get_instance() expects a parker.ConsumePage "
            "or basestring derivative."
        )

    try:
        instance = _instances[uri]
    except KeyError:
        instance = ConsumeModel(page_to_consume)
        _instances[uri] = instance

    return instance