Returns:
                (list[str]) List of public properties
18990
def properties(self):  # type: () -> list
        

        _type = type(self)
        return [_property for _property in dir(_type) if self._is_property(_property)]
1104386
def PublicIPs(self):
		
		if not self.public_ips:  self.public_ips = clc.v2.PublicIPs(server=self,public_ips_lst=self.ip_addresses,session=self.session)

		return(self.public_ips)
681299
def get_public_rooms(self, **kwargs):
        
        return GetPublicRooms(settings=self.settings, **kwargs).call(**kwargs)
155813
function getPublicKeyList(datastore_ctx) {
   const escaped_public_keys = [];
   for (let dk of datastore_ctx.app_public_keys) {
      escaped_public_keys.push(escape(dk.public_key));
   }
   const res = escaped_public_keys.join(',');
   return res;
}
350510
def properties(self):
        
        properties = defaultdict(list)
        for pattern in self.patterns:
            for key, values in pattern.properties.items():
                extend_safe(properties[key], values)
        for rule in self.rules:
            for key, values in rule.properties.items():
                extend_safe(properties[key], values)
        return properties
1057581
def params(self):
        
        if self._params is None:
            self._params = list(filter(lambda attr: isinstance(attr, Param),
                                       [getattr(self, x) for x in dir(self) if x != "params" and
                                        not isinstance(getattr(type(self), x, None), property)]))
        return self._params
288222
def _property_names(self):
        
        property_names = []

        for name in dir(self):
            try:
                attr = getattr(type(self), name)

                if isinstance(attr, property) or isinstance(attr, cached_property):
                    property_names.append(name)

            except AttributeError:
                pass

        return property_names
922606
def get_properties(zos_obj):
    
    prop_get = set(zos_obj._prop_map_get_.keys())
    prop_set = set(zos_obj._prop_map_put_.keys())
    if prop_set.issubset(prop_get):
        prop_get = prop_get.difference(prop_set)
    else:
        msg = 'Assumption all getters are also setters is incorrect!'
        raise NotImplementedError(msg)
    return list(prop_get), list(prop_set)
1281116
def get_public(self):
        '''
        
        '''
        node = self.node.find('public')
        if node is not None:
            return Cpublic(node=node)
        else:
            return None
1227230
public String[] get_property_list() {
        String[] array = new String[size()];
        for (int i = 0; i < size(); i++)
            array[i] = datum(i).name;
        return array;
    }
888205
def public_keys(self):
        """"""
        if not self.public_keys_cache:
            conn = self.conn_factory()
            self.public_keys_cache = conn.export_public_keys(self.identities)
        return self.public_keys_cache
1358766
def properties_list(self, io_handler):
        
        # Get the framework
        framework = self._context.get_framework()

        # Head of the table
        headers = ("Property Name", "Value")

        # Lines
        lines = [item for item in framework.get_properties().items()]

        # Sort lines
        lines.sort()

        # Print the table
        io_handler.write(self._utils.make_table(headers, lines))
239014
def get_clients(self):
        
        public = self.channels['public']
        private = self.channels['private']
        return dict(public.items() + private.items())
993114
def p_property_list(self, p):
        
        if len(p) == 2:
            p[0] = [p[1]]
        else:
            p[1].append(p[3])
            p[0] = p[1]
714924
def get_var_properties(self):
        
        from spyder_kernels.utils.nsview import get_remote_data

        settings = self.namespace_view_settings
        if settings:
            ns = self._get_current_namespace()
            data = get_remote_data(ns, settings, mode='editable',
                                   more_excluded_names=EXCLUDED_NAMES)

            properties = {}
            for name, value in list(data.items()):
                properties[name] = {
                    'is_list':  isinstance(value, (tuple, list)),
                    'is_dict':  isinstance(value, dict),
                    'is_set': isinstance(value, set),
                    'len': self._get_len(value),
                    'is_array': self._is_array(value),
                    'is_image': self._is_image(value),
                    'is_data_frame': self._is_data_frame(value),
                    'is_series': self._is_series(value),
                    'array_shape': self._get_array_shape(value),
                    'array_ndim': self._get_array_ndim(value)
                }

            return repr(properties)
        else:
            return repr(None)
289504
def public_attributes(instance)
      definitions.values.each_with_object({}) do |item, obj|
        key = item.target
        next unless instance.respond_to? key
        val = instance.send(key)
        obj[key] = val unless null == val
      end
    end
1265090
def property_as_list(self, property_name):
        
        try:
            res = self._a_tags[property_name]
        except KeyError:
            return []

        if type(res) == list:
            return res
        else:
            return [res]