Spaces:
Runtime error
Runtime error
BIM Query Deploy
Claude Opus 4.7 (1M context)
deploy: initial BIM Query API on Hugging Face Spaces
e6be672 Download app/models/element.py from 12mhsssss/bimquery-api: direct link, hf CLI and curl.
- Browser
- Download file 11.4 kB
-
https://huggingface.co/spaces/12mhsssss/bimquery-api/resolve/main/app/models/element.py
- Command line
-
hf download hf://spaces/12mhsssss/bimquery-api/app/models/element.py
-
curl -L -o element.py https://huggingface.co/spaces/12mhsssss/bimquery-api/resolve/main/app/models/element.py
11.4 kB
| # Copyright (C) 2026 Mattia Zatelli | |
| # | |
| # This program is free software: you can redistribute it and/or modify | |
| # it under the terms of the GNU Affero General Public License as published by | |
| # the Free Software Foundation, either version 3 of the License, or | |
| # (at your option) any later version. | |
| # | |
| # This program is distributed in the hope that it will be useful, | |
| # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| # GNU Affero General Public License for more details. | |
| # | |
| # You should have received a copy of the GNU Affero General Public License | |
| # along with this program. If not, see <https://www.gnu.org/licenses/>. | |
| """ | |
| Element model for storing IFC element information | |
| """ | |
| import enum | |
| from typing import Dict, Any, List, Optional | |
| from sqlalchemy import Column, Integer, String, Text, JSON, Float, Boolean, ForeignKey, Index | |
| from sqlalchemy.dialects.postgresql import UUID | |
| from sqlalchemy.orm import relationship | |
| from sqlalchemy.sql import func | |
| from sqlalchemy import DateTime | |
| import uuid | |
| from app.core.database import Base | |
| class ElementType(str, enum.Enum): | |
| """Common IFC element types""" | |
| WALL = "IfcWall" | |
| SLAB = "IfcSlab" | |
| BEAM = "IfcBeam" | |
| COLUMN = "IfcColumn" | |
| DOOR = "IfcDoor" | |
| WINDOW = "IfcWindow" | |
| STAIR = "IfcStair" | |
| RAILING = "IfcRailing" | |
| ROOF = "IfcRoof" | |
| SPACE = "IfcSpace" | |
| BUILDING_ELEMENT_PROXY = "IfcBuildingElementProxy" | |
| FURNITURE = "IfcFurniture" | |
| COVERING = "IfcCovering" | |
| CURTAIN_WALL = "IfcCurtainWall" | |
| PLATE = "IfcPlate" | |
| MEMBER = "IfcMember" | |
| FOOTING = "IfcFooting" | |
| PILE = "IfcPile" | |
| OTHER = "Other" | |
| class Element(Base): | |
| """ | |
| IFC Element model | |
| Stores information about individual IFC elements | |
| """ | |
| __tablename__ = "elements" | |
| # Primary key | |
| id = Column(Integer, primary_key=True, index=True) | |
| # External identifiers | |
| ifc_global_id = Column(String(22), nullable=False, index=True, unique=True) # IFC GUID | |
| project_id = Column(Integer, ForeignKey("projects.id", ondelete="CASCADE"), nullable=False, index=True) | |
| # Element classification | |
| ifc_type = Column(String(100), nullable=False, index=True) | |
| element_type = Column(String(50), nullable=True, index=True) # Normalized type | |
| ifc_class = Column(String(100), nullable=True) # Full IFC class name | |
| # Identifiers and labels | |
| name = Column(String(255), nullable=True, index=True) | |
| description = Column(Text, nullable=True) | |
| tag = Column(String(100), nullable=True, index=True) | |
| # Spatial hierarchy | |
| level_name = Column(String(100), nullable=True, index=True) # Storey/Floor | |
| level_elevation = Column(Float, nullable=True) | |
| building_name = Column(String(100), nullable=True) | |
| site_name = Column(String(100), nullable=True) | |
| # Geometric properties | |
| bounding_box = Column(JSON, nullable=True) # {min: [x,y,z], max: [x,y,z]} | |
| centroid = Column(JSON, nullable=True) # [x, y, z] | |
| # Calculated properties | |
| area = Column(Float, nullable=True) # Square meters | |
| volume = Column(Float, nullable=True) # Cubic meters | |
| length = Column(Float, nullable=True) # Linear meters | |
| width = Column(Float, nullable=True) # Meters | |
| height = Column(Float, nullable=True) # Meters | |
| perimeter = Column(Float, nullable=True) # Linear meters | |
| # Material properties | |
| material_name = Column(String(200), nullable=True, index=True) | |
| material_category = Column(String(100), nullable=True, index=True) | |
| material_properties = Column(JSON, nullable=True) | |
| # Classification and properties | |
| properties = Column(JSON, nullable=True) # All IFC properties as key-value pairs | |
| quantities = Column(JSON, nullable=True) # IFC quantities | |
| classifications = Column(JSON, nullable=True) # External classifications (Uniclass, etc.) | |
| # Relationships | |
| parent_element_id = Column(Integer, ForeignKey("elements.id"), nullable=True, index=True) | |
| assembly_id = Column(String(100), nullable=True, index=True) # Assembly identifier | |
| # Status flags | |
| has_geometry = Column(Boolean, default=False) | |
| has_properties = Column(Boolean, default=False) | |
| has_materials = Column(Boolean, default=False) | |
| is_external = Column(Boolean, nullable=True) | |
| is_load_bearing = Column(Boolean, nullable=True) | |
| # Fire safety properties | |
| fire_rating = Column(String(50), nullable=True, index=True) | |
| combustible = Column(Boolean, nullable=True) | |
| # Acoustic properties | |
| acoustic_rating = Column(String(50), nullable=True) | |
| # Thermal properties | |
| thermal_transmittance = Column(Float, nullable=True) # U-value | |
| thermal_mass = Column(Float, nullable=True) | |
| # Timestamps | |
| created_at = Column(DateTime(timezone=True), server_default=func.now()) | |
| updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now()) | |
| # Relationships | |
| project = relationship("Project", back_populates="elements") | |
| parent_element = relationship("Element", remote_side=[id]) | |
| child_elements = relationship("Element", back_populates="parent_element") | |
| query_results = relationship("QueryResult", back_populates="element", cascade="all, delete-orphan") | |
| # Indexes for performance | |
| __table_args__ = ( | |
| Index('idx_elements_project_type', 'project_id', 'ifc_type'), | |
| Index('idx_elements_level', 'project_id', 'level_name'), | |
| Index('idx_elements_material', 'project_id', 'material_name'), | |
| Index('idx_elements_spatial', 'project_id', 'building_name', 'level_name'), | |
| Index('idx_elements_properties', 'project_id', 'has_geometry', 'has_properties'), | |
| ) | |
| def __repr__(self): | |
| return f"<Element(id={self.id}, type='{self.ifc_type}', name='{self.name}')>" | |
| def to_dict(self) -> Dict[str, Any]: | |
| """Convert to dictionary for API responses""" | |
| return { | |
| "id": f"el_{self.id}", | |
| "ifc_global_id": self.ifc_global_id, | |
| "ifc_type": self.ifc_type, | |
| "element_type": self.element_type, | |
| "name": self.name, | |
| "description": self.description, | |
| "tag": self.tag, | |
| "level_name": self.level_name, | |
| "level_elevation": self.level_elevation, | |
| "building_name": self.building_name, | |
| "bounding_box": self.bounding_box, | |
| "centroid": self.centroid, | |
| "area": self.area, | |
| "volume": self.volume, | |
| "length": self.length, | |
| "width": self.width, | |
| "height": self.height, | |
| "material_name": self.material_name, | |
| "material_category": self.material_category, | |
| "properties": self.properties or {}, | |
| "quantities": self.quantities or {}, | |
| "classifications": self.classifications or {}, | |
| "has_geometry": self.has_geometry, | |
| "has_properties": self.has_properties, | |
| "has_materials": self.has_materials, | |
| "is_external": self.is_external, | |
| "is_load_bearing": self.is_load_bearing, | |
| "fire_rating": self.fire_rating, | |
| "thermal_transmittance": self.thermal_transmittance, | |
| } | |
| def get_summary(self) -> Dict[str, Any]: | |
| """Get element summary for listings""" | |
| return { | |
| "id": f"el_{self.id}", | |
| "ifc_global_id": self.ifc_global_id, | |
| "ifc_type": self.ifc_type, | |
| "name": self.name, | |
| "level_name": self.level_name, | |
| "area": self.area, | |
| "volume": self.volume, | |
| "material_name": self.material_name, | |
| "bounding_box": self.bounding_box, | |
| } | |
| def get_public_id(cls, internal_id: int) -> str: | |
| """Convert internal ID to public format""" | |
| return f"el_{internal_id}" | |
| def parse_public_id(cls, public_id: str) -> Optional[int]: | |
| """Parse public ID to internal ID""" | |
| if not public_id.startswith("el_"): | |
| return None | |
| try: | |
| return int(public_id[3:]) | |
| except ValueError: | |
| return None | |
| def normalize_element_type(self) -> str: | |
| """Normalize IFC type to standard categories""" | |
| type_mapping = { | |
| "IfcWall": "Wall", | |
| "IfcWallStandardCase": "Wall", | |
| "IfcSlab": "Floor", | |
| "IfcBeam": "Beam", | |
| "IfcColumn": "Column", | |
| "IfcDoor": "Door", | |
| "IfcWindow": "Window", | |
| "IfcStair": "Stair", | |
| "IfcStairFlight": "Stair", | |
| "IfcRailing": "Railing", | |
| "IfcRoof": "Roof", | |
| "IfcSpace": "Space", | |
| "IfcRoom": "Room", | |
| "IfcFurniture": "Furniture", | |
| "IfcCovering": "Covering", | |
| "IfcCurtainWall": "Curtain Wall", | |
| "IfcPlate": "Plate", | |
| "IfcMember": "Member", | |
| "IfcFooting": "Foundation", | |
| "IfcPile": "Pile", | |
| } | |
| return type_mapping.get(self.ifc_type, "Other") | |
| def get_property_value(self, property_name: str) -> Any: | |
| """Get specific property value""" | |
| if not self.properties: | |
| return None | |
| return self.properties.get(property_name) | |
| def set_property_value(self, property_name: str, value: Any): | |
| """Set specific property value""" | |
| if not self.properties: | |
| self.properties = {} | |
| self.properties[property_name] = value | |
| def get_classification(self, system: str) -> Optional[str]: | |
| """Get classification by system (e.g., 'Uniclass', 'OmniClass')""" | |
| if not self.classifications: | |
| return None | |
| return self.classifications.get(system) | |
| def has_fire_rating(self) -> bool: | |
| """Check if element has fire rating""" | |
| return bool(self.fire_rating and self.fire_rating != "None") | |
| def is_structural(self) -> bool: | |
| """Check if element is structural""" | |
| structural_types = { | |
| "IfcWall", "IfcBeam", "IfcColumn", "IfcSlab", | |
| "IfcFooting", "IfcPile", "IfcMember" | |
| } | |
| return self.ifc_type in structural_types or self.is_load_bearing == True | |
| def get_area_by_type(self) -> Optional[float]: | |
| """Get area based on element type (wall area, floor area, etc.)""" | |
| if self.ifc_type in ["IfcWall", "IfcCurtainWall"]: | |
| return self.area # Wall area | |
| elif self.ifc_type in ["IfcSlab", "IfcSpace", "IfcRoom"]: | |
| return self.area # Floor area | |
| elif self.ifc_type in ["IfcWindow", "IfcDoor"]: | |
| return self.area # Opening area | |
| return self.area | |
| def calculate_carbon_footprint(self) -> Optional[float]: | |
| """Calculate approximate carbon footprint (if material data available)""" | |
| # This would integrate with material carbon databases | |
| # Placeholder implementation | |
| if not self.volume or not self.material_name: | |
| return None | |
| # Simple carbon factors (kg CO2e per m3) | |
| carbon_factors = { | |
| "Concrete": 400, | |
| "Steel": 2500, | |
| "Timber": 50, | |
| "Brick": 300, | |
| "Aluminum": 8000, | |
| } | |
| for material, factor in carbon_factors.items(): | |
| if material.lower() in (self.material_name or "").lower(): | |
| return self.volume * factor | |
| return None |