def _set_attr_name_map(self): """ build a map for attributes names and display names Dict containing all display_name to attr_name mappings for all objects used in the current query Example: { Program: {"Program URL": "url", "Code": "slug", ...} ...} """ self.attr_name_map = {} for object_query in self.query: object_name = object_query["object_name"] object_class = self.object_map[object_name] aliases = AttributeInfo.gather_aliases(object_class) self.attr_name_map[object_class] = {} for key, value in aliases.items(): filter_by = None if isinstance(value, dict): filter_name = value.get("filter_by", None) if filter_name is not None: filter_by = getattr(object_class, filter_name, None) name = value["display_name"] else: name = value if name: self.attr_name_map[object_class][name.lower()] = ( key.lower(), filter_by)
def _set_attr_name_map(self): """ build a map for attributes names and display names Dict containing all display_name to attr_name mappings for all objects used in the current query Example: { Program: {"Program URL": "url", "Code": "slug", ...} ...} """ self.attr_name_map = {} for object_query in self.query: object_name = object_query["object_name"] object_class = self.object_map[object_name] tgt_class = object_class if object_name == "Snapshot": child_type = self._get_snapshot_child_type(object_query) tgt_class = getattr(models.all_models, child_type, object_class) aliases = AttributeInfo.gather_aliases(tgt_class) self.attr_name_map[tgt_class] = {} for key, value in aliases.items(): filter_by = None if isinstance(value, dict): filter_name = value.get("filter_by", None) if filter_name is not None: filter_by = getattr(tgt_class, filter_name, None) name = value["display_name"] else: name = value if name: self.attr_name_map[tgt_class][name.lower()] = (key.lower(), filter_by)
def _get_reserved_names(cls, definition_type): """Get a list of all attribute names in all objects. On first call this function computes all possible names that can be used by any model and stores them in a static frozen set. All later calls just get this set. Returns: frozen set containing all reserved attribute names for the current object. """ with benchmark("Generate a list of all reserved attribute names"): if not cls._reserved_names.get(definition_type): definition_map = { model._inflector.table_singular: model for model in ggrc.models.all_models.all_models } definition_model = definition_map.get(definition_type) if not definition_model: raise ValueError("Invalid definition type") aliases = AttributeInfo.gather_aliases(definition_model) cls._reserved_names[definition_type] = frozenset( (value["display_name"] if isinstance(value, dict ) else value).lower() for value in aliases.values() if value) return cls._reserved_names[definition_type]
def _get_reserved_names(cls, definition_type): """Get a list of all attribute names in all objects. On first call this function computes all possible names that can be used by any model and stores them in a static frozen set. All later calls just get this set. Returns: frozen set containing all reserved attribute names for the current object. """ # pylint: disable=protected-access # The _inflector is a false positive in our app. with benchmark("Generate a list of all reserved attribute names"): if not cls._reserved_names.get(definition_type): definition_map = {model._inflector.table_singular: model for model in ggrc.models.all_models.all_models} definition_map.update({model._inflector.model_singular: model for model in ggrc.models.all_models.all_models}) definition_model = definition_map.get(definition_type) if not definition_model: raise ValueError("Invalid definition type") aliases = AttributeInfo.gather_aliases(definition_model) cls._reserved_names[definition_type] = frozenset( (value["display_name"] if isinstance( value, dict) else value).lower() for value in aliases.values() if value ) return cls._reserved_names[definition_type]
def test_gather_aliases(self): """Test gather all aliases.""" class Child(object): # pylint: disable=too-few-public-methods _aliases = { "child_normal": "normal", "child_extended": { "display_name": "Extended", }, "child_filter_only": { "display_name": "Extended", "filter_only": True, }, } class Parent(Child): # pylint: disable=too-few-public-methods _aliases = { "parent_normal": "normal", "parent_extended": { "display_name": "Extended", }, "parent_filter_only": { "display_name": "Extended", "filter_only": True, }, } self.assertEqual( AttributeInfo.gather_aliases(Parent), { "parent_normal": "normal", "parent_extended": { "display_name": "Extended", }, "parent_filter_only": { "display_name": "Extended", "filter_only": True, }, "child_normal": "normal", "child_extended": { "display_name": "Extended", }, "child_filter_only": { "display_name": "Extended", "filter_only": True, }, } )
def test_gather_aliases(self): """Test gather all aliases.""" class Child(object): # pylint: disable=too-few-public-methods _aliases = { "child_normal": "normal", "child_extended": { "display_name": "Extended", }, "child_filter_only": { "display_name": "Extended", "filter_only": True, }, } class Parent(Child): # pylint: disable=too-few-public-methods _aliases = { "parent_normal": "normal", "parent_extended": { "display_name": "Extended", }, "parent_filter_only": { "display_name": "Extended", "filter_only": True, }, } self.assertEqual( AttributeInfo.gather_aliases(Parent), { "parent_normal": "normal", "parent_extended": { "display_name": "Extended", }, "parent_filter_only": { "display_name": "Extended", "filter_only": True, }, "child_normal": "normal", "child_extended": { "display_name": "Extended", }, "child_filter_only": { "display_name": "Extended", "filter_only": True, }, } )
def _get_model_names(cls, model): """Get tuple of all attribute names for model. Args: model: Model class. Returns: Tuple of all attributes for provided model. """ if not model: raise ValueError("Invalid definition type") aliases = AttributeInfo.gather_aliases(model) return ((value["display_name"] if isinstance(value, dict) else value).lower() for value in aliases.values() if value)
def _get_model_names(cls, model): """Get tuple of all attribute names for model. Args: model: Model class. Returns: Tuple of all attributes for provided model. """ if not model: raise ValueError("Invalid definition type") aliases = AttributeInfo.gather_aliases(model) return ( (value["display_name"] if isinstance(value, dict) else value).lower() for value in aliases.values() if value )
def _set_attr_name_map(self): """ build a map for attributes names and display names Dict containing all display_name to attr_name mappings for all objects used in the current query Example: { Program: {"Program URL": "url", "Code": "slug", ...} ...} """ self.attr_name_map = {} for object_query in self.query: object_name = object_query["object_name"] object_class = self.object_map[object_name] aliases = AttributeInfo.gather_aliases(object_class) self.attr_name_map[object_class] = {} for key, value in aliases.items(): filter_by = None if isinstance(value, dict): filter_name = value.get("filter_by", None) if filter_name is not None: filter_by = getattr(object_class, filter_name, None) value = value["display_name"] if value: self.attr_name_map[object_class][value.lower()] = ( key.lower(), filter_by) if not self.ca_disabled: custom_attrs = AttributeInfo.get_custom_attr_definitions( object_class) else: custom_attrs = {} for key, definition in custom_attrs.items(): if not key.startswith("__custom__:") or \ "display_name" not in definition: continue try: # Global custom attribute definition can only have a single id on # their name, so it is safe for that. Currently the filters do not # work with object level custom attributes. attr_id = definition["definition_ids"][0] except KeyError: continue filter_by = CustomAttributeValue.mk_filter_by_custom( object_class, attr_id) name = definition["display_name"].lower() self.attr_name_map[object_class][name] = (name, filter_by)
def attributes_map(cls): if cls.CACHED_ATTRIBUTE_MAP: return cls.CACHED_ATTRIBUTE_MAP aliases = AttributeInfo.gather_aliases(cls) cls.CACHED_ATTRIBUTE_MAP = {} for key, value in aliases.items(): if isinstance(value, dict): name = value["display_name"] filter_by = None if value.get("filter_by"): filter_by = getattr(cls, value["filter_by"], None) else: name = value filter_by = None if not name: continue cls.CACHED_ATTRIBUTE_MAP[name.lower()] = (key.lower(), filter_by) return cls.CACHED_ATTRIBUTE_MAP
def attributes_map(cls): if cls.CACHED_ATTRIBUTE_MAP: return cls.CACHED_ATTRIBUTE_MAP aliases = AttributeInfo.gather_aliases(cls) cls.CACHED_ATTRIBUTE_MAP = {} for key, value in aliases.items(): if isinstance(value, dict): name = value["display_name"] filter_by = None if value.get("filter_by"): filter_by = getattr(cls, value["filter_by"], None) else: name = value filter_by = None if not name: continue tmp = getattr(cls, "PROPERTY_TEMPLATE", "{}") name = tmp.format(name) key = tmp.format(key) cls.CACHED_ATTRIBUTE_MAP[name.lower()] = (key.lower(), filter_by) return cls.CACHED_ATTRIBUTE_MAP
def attributes_map(cls): """Get class attributes map""" if cls.CACHED_ATTRIBUTE_MAP: return cls.CACHED_ATTRIBUTE_MAP aliases = AttributeInfo.gather_aliases(cls) cls.CACHED_ATTRIBUTE_MAP = {} for key, value in aliases.items(): if isinstance(value, dict): name = value["display_name"] filter_by = None if value.get("filter_by"): filter_by = getattr(cls, value["filter_by"], None) else: name = value filter_by = None if not name: continue tmp = getattr(cls, "PROPERTY_TEMPLATE", "{}") name = tmp.format(name) key = tmp.format(key) cls.CACHED_ATTRIBUTE_MAP[name.lower()] = (key.lower(), filter_by) return cls.CACHED_ATTRIBUTE_MAP