Get full asset from name of id

            :param str name: Symbol name or asset id (e.g. 1.3.0)
334240
def get_asset(self, name, **kwargs):
        
        if len(name.split(".")) == 3:
            return self.get_objects([name], **kwargs)[0]
        else:
            return self.lookup_asset_symbols([name], **kwargs)[0]
1323980
private function getFullQualifiedAssetName($name)
    {
        $name = $this->getUnquotedAssetName($name);

        if (strpos($name, '.') === false) {
            $name = $this->getName() . '.' . $name;
        }

        return strtolower($name);
    }
642548
def get_rule_id_from_name(self, name):
        
        results = self.client.call('SoftLayer_Virtual_PlacementGroup_Rule', 'getAllObjects')
        return [result['id'] for result in results if result['keyName'] == name.upper()]
1068242
def layer_id_from_name(shortname)
      layer = layers.find { |l| l.shortname == shortname }
      raise "Layer #{layer} not found" unless layer
      layer.id
    end
111439
def get_asset_classes_for_security(self, namespace: str, symbol: str) -> List[AssetClass]:
        
        full_symbol = symbol
        if namespace:
            full_symbol = f"{namespace}:{symbol}"

        result = (
            self.session.query(AssetClassStock)
            .filter(AssetClassStock.symbol == full_symbol)
            .all()
        )
        return result
909679
def get(self, name):
        '''
        
        '''
        if name.startswith('#'):
            return self.tags.get(name[1:])
        return self.props.get(name)
935357
def _fullname(o):
    """"""
    return o.__module__ + "." + o.__name__ if o.__module__ else o.__name__
5588
def get_full_name(src):
    """"""

    if hasattr(src, "_full_name_"):
        return src._full_name_
    if hasattr(src, "is_decorator"):
        # Our own decorator or binder
        if hasattr(src, "decorator"):
            # Our own binder
            _full_name_ = str(src.decorator)
            # It's a short-living object, so we don't cache result
        else:
            # Our own decorator
            _full_name_ = str(src)
            try:
                src._full_name_ = _full_name_
            except AttributeError:
                pass
            except TypeError:
                pass
    elif hasattr(src, "im_class"):
        # Bound method
        cls = src.im_class
        _full_name_ = get_full_name(cls) + "." + src.__name__
        # It's a short-living object, so we don't cache result
    elif hasattr(src, "__module__") and hasattr(src, "__name__"):
        # Func or class
        _full_name_ = (
            ("<unknown module>" if src.__module__ is None else src.__module__)
            + "."
            + src.__name__
        )
        try:
            src._full_name_ = _full_name_
        except AttributeError:
            pass
        except TypeError:
            pass
    else:
        # Something else
        _full_name_ = str(get_original_fn(src))
    return _full_name_
216572
def get_source_name(self, name):
        """"""
        if name not in self.like.sourceNames():
            name = self.roi.get_source_by_name(name).name
        return name
234423
def _get_ids_from_name_private(self, name):
        """"""
        results = self.list_private_images(name=name)
        return [result['id'] for result in results]
709752
def get_product(id=None, name=None):
    
    content = get_product_raw(id, name)
    if content:
        return utils.format_json(content)
1234403
def from_name(api_url, name, dry_run=False):
        
        return DataSet(
            '/'.join([api_url, name]).rstrip('/'),
            token=None,
            dry_run=dry_run
        )
559352
def _get_input_format_from_name(self, name):
        
        try:
            int(name)
            src_format = 'ISOnumeric'
        except ValueError:
            if len(name) == 2:
                src_format = 'ISO2'
            elif len(name) == 3:
                src_format = 'ISO3'
            else:
                src_format = 'regex'
        return src_format
182190
def _get_asset(self, asset_uid):
        
        uri = self.uri + '/v2/assets/' + asset_uid

        headers = self._get_headers()

        return self.service._get(uri, headers=headers)
655781
def full_name
      result = read_attribute(:full_name).presence
      result ||= [ family_name.presence, given_name.presence ].compact.join(' ')

      result
    end
31816
def load_name(self, name):
        
        locator = self._make_locator()

        path = locator.find_name(name, self.search_dirs)

        return self.read(path)
509523
def _name_attribute_to_string(self, name):
        
        return "".join(
            "/{}={}".format(
                self._get_oid_name(attr.oid),
                attr.value,
            )
            for attr in name
        )