Create a Property instance from a list of well-known property names
        @param property_names: a non-empty list of property names
324421
def create_from_names(cls, property_names):
        
        assert property_names

        if len(property_names) == 1:
            name = property_names[0]
            subproperties = None
        else:
            name = (_PROP_MEMSAFETY if set(property_names) == _MEMSAFETY_SUBPROPERTIES
                    else "unknown property")
            subproperties = list(property_names)

        is_well_known = name in _VALID_RESULTS_PER_PROPERTY.keys()
        is_svcomp = is_well_known and (_PROP_SAT not in property_names)

        return cls(None, is_well_known, is_svcomp, name, subproperties)
1125411
def [](property_name)
      if get_property(property_name).is_a?(::OData::ComplexType)
        get_property(property_name)
      else
        get_property(property_name).value
      end
    rescue NoMethodError
      raise ArgumentError, "Unknown property: #{property_name}"
    end
518574
public static Map<String, Object> listProperties(IfcObject ifcObject, String propertySetName) {
		Map<String, Object> result = new HashMap<>();
		for (IfcRelDefines ifcRelDefines : ifcObject.getIsDefinedBy()) {
			if (ifcRelDefines instanceof IfcRelDefinesByProperties) {
				IfcRelDefinesByProperties ifcRelDefinesByProperties = (IfcRelDefinesByProperties) ifcRelDefines;
				IfcPropertySetDefinition propertySetDefinition = ifcRelDefinesByProperties.getRelatingPropertyDefinition();
				if (propertySetDefinition instanceof IfcPropertySet) {
					IfcPropertySet ifcPropertySet = (IfcPropertySet) propertySetDefinition;
					if (ifcPropertySet.getName() != null && ifcPropertySet.getName().equalsIgnoreCase(propertySetName)) {
						for (IfcProperty ifcProperty : ifcPropertySet.getHasProperties()) {
							if (ifcProperty instanceof IfcPropertySingleValue) {
								IfcPropertySingleValue propertyValue = (IfcPropertySingleValue) ifcProperty;
								result.put(propertyValue.getName(), nominalValueToObject(propertyValue.getNominalValue()));
							}
						}
					}
				}
			}
		}
		return result;
	}
509155
def init_property_classifiers
      @local_std_prop_hash = {}
      @alias_std_prop_map = append_ancestor_enum(@local_std_prop_hash) { |par| par.alias_standard_attribute_hash }
      @local_prop_hash = {}
      @prop_hash = append_ancestor_enum(@local_prop_hash) { |par| par.property_hash }
      @attributes = Enumerable::Enumerator.new(@prop_hash, :each_key)
      @local_mndty_attrs = Set.new
      @local_defaults = {}
      @defaults = append_ancestor_enum(@local_defaults) { |par| par.defaults }
    end
1263631
public PropertyDescription[] createPropertyDescriptions(
                                                   PropertyDescriptor[] pds) {

        if (pds == null) {
            return null;
        }

        PropertyDescription[] descriptions = 
            new PropertyDescription[pds.length];

        for (int i = 0; i < pds.length; i++) {
            descriptions[i] = new PropertyDescription(pds[i], this);
        }

        return descriptions;
    }
1137279
def expand_no_defaults (property_sets):
    
    assert is_iterable_typed(property_sets, property_set.PropertySet)
    # First make all features and subfeatures explicit
    expanded_property_sets = [ps.expand_subfeatures() for ps in property_sets]

    # Now combine all of the expanded property_sets
    product = __x_product (expanded_property_sets)

    return [property_set.create(p) for p in product]
1088404
function convertPropertyNames (context, pkg, map , root, waiting) {
	if(!map) {
		return map;
	}
	var clone = {}, value;
	for(var property in map ) {
		value = convertName(context, pkg, map, root, property, waiting);
		if(typeof value === 'string') {
			clone[value] = map[property];
		}

		// do root paths b/c we don't know if they are going to be included with the package name or not.
		if(root) {
			value = convertName(context, pkg, map, false, property, waiting);
			if(typeof value === 'string') {
				clone[value] = map[property];
			}
		}
	}
	return clone;
}
1073281
def MI_createInstance(self,
                          env,
                          instance):
        # pylint: disable=invalid-name
        

        logger = env.get_logger()
        logger.log_debug('CIMProvider MI_createInstance called...')
        rval = None
        ch = env.get_cimom_handle()
        cimClass = ch.GetClass(instance.classname,
                               instance.path.namespace,
                               LocalOnly=False,
                               IncludeQualifiers=True)
        # CIMOM has already filled in default property values for
        # props with default values, if values not supplied by client.
        rval = self.set_instance(env=env,
                                 instance=instance,
                                 previous_instance=None,
                                 cim_class=cimClass)
        rval = build_instance_name(rval, cimClass)
        logger.log_debug('CIMProvider MI_createInstance returning')
        return rval
449229
def get_property_list(self):
        
        property_list = set()
        for x in self.statements:
            property_list.add(x.get_prop_nr())

        return list(property_list)
413916
def instantiate_by_name(self, object_name):
        
        if object_name not in self.instances:
            instance = self.instantiate_from_data(self.environment[object_name])

            self.instances[object_name] = instance
            return instance
        else:
            return self.instances[object_name]
317350
def get_properties(attributes):
        
        return [key for key, value in six.iteritems(attributes)
                if isinstance(value, property)]
663088
def json_dict_copy(json_object, property_list, defaultValue=None):
    
    ret = {}
    for prop in property_list:
        p_name = prop["name"]
        for alias in prop.get("alternateName", []):
            if json_object.get(alias) is not None:
                ret[p_name] = json_object.get(alias)
                break
        if not p_name in ret:
            if p_name in json_object:
                ret[p_name] = json_object[p_name]
            elif defaultValue is not None:
                ret[p_name] = defaultValue

    return ret
793394
def missing_property_names(self):
        

        propname = lambda x: self.__prop_names__[x]
        missing = []
        for x in self.__required__:

            # Allow the null type
            propinfo = self.propinfo(propname(x))
            null_type = False
            if 'type' in propinfo:
                type_info = propinfo['type']
                null_type = (type_info == 'null'
                             or isinstance(type_info, (list, tuple))
                             and 'null' in type_info)
            elif 'oneOf' in propinfo:
                for o in propinfo['oneOf']:
                    type_info = o.get('type')
                    if type_info and type_info == 'null' \
                            or isinstance(type_info, (list, tuple)) \
                            and 'null' in type_info:
                        null_type = True
                        break

            if (propname(x) not in self._properties and null_type) or \
                    (self._properties[propname(x)] is None and not null_type):
                missing.append(x)

        return missing
1080137
def get_property_names(obj):
        
        property_names = []
        
        for property_name in dir(obj):

            property = getattr(obj, property_name)

            if PropertyReflector._is_property(property, property_name):
                property_names.append(property_name)

        return property_names
1263796
@SuppressWarnings("unchecked")
    public final <C extends T> PropertyList<C> getProperties(final String name) {
        final PropertyList<C> list = new PropertyList<C>();
        for (final T p : this) {
            if (p.getName().equalsIgnoreCase(name)) {
                list.add((C) p);
            }
        }
        return list;
    }
1241331
def _extract_parameters_from_properties(properties):
    """"""
    new_properties = {}
    parameters = []
    for key, value in six.iteritems(properties):
        if key.startswith(_PARAMETER_PREFIX):
            parameters.append((key.replace(_PARAMETER_PREFIX, ""), value))
        else:
            new_properties[key] = value

    return new_properties, sorted(parameters)
386641
private PropertyDescriptor newPropertyDescriptor(final Attributes attributes) {

        final PropertyDescriptor propDesc = FACTORY.createPropertyDescriptor();
        LOG.debug("property name={}", attributes.getValue("name"));
        LOG.debug("property jcrType={}", attributes.getValue("jcrType"));
        propDesc.setName(attributes.getValue("name"));
        propDesc.setJcrType(PropertyValueType.fromValue(attributes.getValue("jcrType")));
        return propDesc;
    }