Get an item from the IPython environment.
166857
def get_notebook_item(name):
  
  env = notebook_environment()
  return google.datalab.utils.get_item(env, name)
719763
def get_root_item(self, item):
        """"""
        root_item = item
        while isinstance(root_item.parent(), QTreeWidgetItem):
            root_item = root_item.parent()
        return root_item
636301
def _get(self, item):
        
        if item not in object.__getattribute__(self, "_protectedItems") \
                and item[0] != "_":
            data = object.__getattribute__(self, "_data")
            if item in data:
                return data[item]
        return object.__getattribute__(self, item)
1108014
def item(*args):
    '''
    
    '''
    ret = {}
    for arg in args:
        try:
            ret[arg] = __pillar__[arg]
        except KeyError:
            pass
    return ret
967364
def _process_getitem(self, node, **kwargs):
        

        with self._interpolation():
            with self._python_bool_wrapper(**kwargs) as new_kwargs:
                self._process_node(node.node, **new_kwargs)

                if isinstance(node.arg, nodes.Slice):
                    self.output.write('.slice(')

                    if node.arg.step is not None:
                        raise Exception('The step argument is not supported when slicing.')

                    if node.arg.start is None:
                        self.output.write('0')
                    else:
                        self._process_node(node.arg.start, **new_kwargs)

                    if node.arg.stop is None:
                        self.output.write(')')
                    else:
                        self.output.write(',')
                        self._process_node(node.arg.stop, **new_kwargs)
                        self.output.write(')')
                else:
                    self.output.write('[')
                    self._process_node(node.arg, **new_kwargs)
                    self.output.write(']')
563703
def get_value(cls, object_version, key):
        """"""
        obj = cls.get(object_version, key)
        return obj.value if obj else None
992154
def get(self, key, default=None):
        
        if key in self:
            return self.items_dict[self.__dict__[str(type(key))][key]]
        else:
            return default
967127
def get(self, item):
        
        e = self._deps.get(item)
        if e is None:
            return self.get_default()
        return e.parent
1123936
def get_value(self, key, args, kwargs):
        """"""
        if hasattr(self._item, key):
            return getattr(self._item, key)
        return super().get_value(key, args, kwargs)
231479
def get_current_item(self):
        """"""
        l = self.selectedIndexes()
        if len(l) > 0:
            return self.model().get_item(l[0])
740890
def get(self, cid, pvs=None, fields=[]):
        ''''''
        request = TOPRequest('taobao.itempropvalues.get')
        if not fields:
            propValue = PropValue()
            fields = propValue.fields
        request['fields'] = fields
        if pvs!=None:
            request['pvs'] = pvs
        request['cid'] = cid
        self.create(self.execute(request))
        return self.prop_values
432785
def item(self):
        """"""
        url = self._contentURL
        return Item(url=self._contentURL,
                    securityHandler=self._securityHandler,
                    proxy_url=self._proxy_url,
                    proxy_port=self._proxy_port,
                    initalize=True)
1365692
def getitem(source, index):
    
    if isinstance(index, builtins.slice):
        return slice.raw(source, index.start, index.stop, index.step)
    if isinstance(index, int):
        return item.raw(source, index)
    raise TypeError("Not a valid index (int or slice)")
298845
def items(self):
        """"""
        if self.scraper.current_item is not self:
            self._move_here()

        if self._items is None:
            self._items = ItemList()
            self._items.scraper = self.scraper
            self._items.collection = self
            for i in self.scraper._fetch_itemslist(self):
                i.parent = self
                if i.type == TYPE_DATASET and i.dialect is None:
                    i.dialect = self.scraper.dialect
                self._items.append(i)
        return self._items
270560
def get(self, parent_cid=None, cids=[], fields=[]):
        ''''''
        request = TOPRequest('taobao.itemcats.get')
        if not fields:
            itemCat = ItemCat()
            fields = itemCat.fields
        request['fields'] = fields
        if parent_cid!=None:
            request['parent_cid'] = parent_cid
        if cids:
            request['cids'] = ','.join([str(cid) for cid in cids])
        self.create(self.execute(request))
        return self.item_cats
368041
def get(self, item):
        
        if item not in self._item_cache:
            try:
                item = self.__getitem__(item)
            except KeyError:
                item = None
            self._item_cache[item] = item
        return self._item_cache[item]
372979
def get_item(self, index):
        
        row = index.row() if hasattr(index, "row") else index
        try:
            return self.collection[row]
        except IndexError:  # invalid index for exemple
            return None