Returns user specified Lob values
559300
@Override
    public Object beforeInsert(S storable) throws PersistException {
        // Capture user lob values for later and replace with new locators.
        int length = mLobProperties.length;
        Object[] userLobs = new Object[length];
        for (int i=0; i<length; i++) {
            LobProperty<Lob> prop = mLobProperties[i];
            Object userLob = storable.getPropertyValue(prop.mName);
            userLobs[i] = userLob;
            if (userLob != null) {
                Object lob = prop.createNewLob(mBlockSize);
                storable.setPropertyValue(prop.mName, lob);
            }
        }
        return userLobs;
    }
97294
def values(self):
        
        if self.root.stale:
            self.root.update(self.now, None)
        return self._values.loc[:self.now]
944594
def _get_user_groups(self, user):
        '''
        
        '''
        return [g.gr_name for g in grp.getgrall()
                if user in g.gr_mem] + [grp.getgrgid(pwd.getpwnam(user).pw_gid).gr_name]
1237304
def _list_locators(self):
        
        with _handle_client_exception():
            response = self.client.get_account()

        for container in response[1]:
            yield container.pop('name'), container
1040728
def listRemoteDatawraps(location = conf.pyGeno_REMOTE_LOCATION) :
	""""""
	loc = location + "/datawraps.json"
	response = urllib2.urlopen(loc)
	js = json.loads(response.read())
	
	return js
937682
@Override
    public Iterable<Long> getUserItemTimestamps(U u, I i) {
        if (userItemTimestamps.containsKey(u) && userItemTimestamps.get(u).containsKey(i)) {
            return userItemTimestamps.get(u).get(i);
        }
        return null;
    }
805804
def _opt_to_args(cls, opt, val):
        
        no_value = (
            "alloptions", "all-logs", "batch", "build", "debug",
            "experimental", "list-plugins", "list-presets", "list-profiles",
            "noreport", "quiet", "verify"
        )
        count = ("verbose",)
        if opt in no_value:
            return ["--%s" % opt]
        if opt in count:
            return ["--%s" % opt for d in range(0, int(val))]
        return ["--" + opt + "=" + val]
290965
def get_values(self):
        """"""
        attrs = super(Host, self).get_values()
        if '_owner_type' in attrs and attrs['_owner_type'] is not None:
            attrs['owner_type'] = attrs.pop('_owner_type')
        else:
            attrs.pop('_owner_type')
        return attrs
241721
def valid_loc(self,F=None):
        """"""
        if F is not None:
            return [i for i,f in enumerate(F) if np.all(f < self.max_fit) and np.all(f >= 0)]
        else:
            return [i for i,f in enumerate(self.F) if np.all(f < self.max_fit) and np.all(f >= 0)]
1162821
def get_public_members(obj):
    
    return {attr: getattr(obj, attr) for attr in dir(obj)
            if not attr.startswith("_")
            and not hasattr(getattr(obj, attr), '__call__')}
689935
def __get_values(self):
        """"""
        values = []

        if self.__remote:
            description = self.__client.describe(self.__point)
            if description is not None:
                if description['type'] != 'Point':
                    raise IOTUnknown('%s is not a Point' % self.__point)
                values = description['meta']['values']
        else:
            limit = 100
            offset = 0
            while True:
                new = self.__point.list(limit=limit, offset=offset)
                values += new
                if len(new) < limit:
                    break
                offset += limit

            # Unlike for describe, value comments are keyed by language here, so unwrap to have same layout as for
            # describe call (default language only, if available).
            lang = self.__client.default_lang
            for value in values:
                value['comment'] = value['comment'].get(lang, None) if value['comment'] else None

        return values
323031
def getent(refresh=False):
    '''
    
    '''
    if 'user.getent' in __context__ and not refresh:
        return __context__['user.getent']

    ret = []
    for data in pwd.getpwall():
        ret.append(info(data.pw_name))
    __context__['user.getent'] = ret
    return ret
830479
def _get_contents(self):
        """"""
        def files():
            for value in super(GlobBundle, self)._get_contents():
                for path in glob.glob(value):
                    yield path
        return list(files())
780445
def get_values(self, profile, bitarray, status):
        '''  '''
        if not self.init_ok or profile is None:
            return [], {}

        output = OrderedDict({})
        for source in profile.contents:
            if not source.name:
                continue
            if source.name == 'value':
                output.update(self._get_value(source, bitarray))
            if source.name == 'enum':
                output.update(self._get_enum(source, bitarray))
            if source.name == 'status':
                output.update(self._get_boolean(source, status))
        return output.keys(), output
755109
def _get_options(ret=None):
    '''
    
    '''
    defaults = {'host': 'salt',
                'user': 'salt',
                'pass': 'salt',
                'db': 'salt',
                'port': 3306,
                'ssl_ca': None,
                'ssl_cert': None,
                'ssl_key': None}

    attrs = {'host': 'host',
             'user': 'user',
             'pass': 'pass',
             'db': 'db',
             'port': 'port',
             'ssl_ca': 'ssl_ca',
             'ssl_cert': 'ssl_cert',
             'ssl_key': 'ssl_key'}

    _options = salt.returners.get_returner_options(__virtualname__,
                                                   ret,
                                                   attrs,
                                                   __salt__=__salt__,
                                                   __opts__=__opts__,
                                                   defaults=defaults)
    # post processing
    for k, v in six.iteritems(_options):
        if isinstance(v, six.string_types) and v.lower() == 'none':
            # Ensure 'None' is rendered as None
            _options[k] = None
        if k == 'port':
            # Ensure port is an int
            _options[k] = int(v)

    return _options
1245533
def get_last_user(self, refresh=False):
        """"""
        if refresh:
            self.refresh_complex_value('sl_UserCode')
        val = self.get_complex_value("sl_UserCode")
        # Syntax string: UserID="<pin_slot>" UserName="<pin_code_name>"
        # See http://wiki.micasaverde.com/index.php/Luup_UPnP_Variables_and_Actions#DoorLock1

        try:
            # Get the UserID="" and UserName="" fields separately
            raw_userid, raw_username = val.split(' ')
            # Get the right hand value without quotes of UserID="<here>"
            userid = raw_userid.split('=')[1].split('"')[1]
            # Get the right hand value without quotes of UserName="<here>"
            username = raw_username.split('=')[1].split('"')[1]
        except Exception as ex:
            logger.error('Got unsupported user string {}: {}'.format(val, ex))
            return None

        return ( userid, username )
184986
def _lons(self):
        """"""
        lons = _np.linspace(0.0, 360.0 - 360.0 / self.nlon, num=self.nlon)
        return lons