271 lines
9.2 KiB
Python
271 lines
9.2 KiB
Python
# IfcOpenShell - IFC toolkit and geometry engine
|
|
# Copyright (C) 2021 Dion Moult <dion@thinkmoult.com>
|
|
#
|
|
# This file is part of IfcOpenShell.
|
|
#
|
|
# IfcOpenShell is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Lesser General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# IfcOpenShell 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 Lesser General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Lesser General Public License
|
|
# along with IfcOpenShell. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
import datetime
|
|
from re import findall
|
|
from typing import Any, Literal, Union, overload
|
|
|
|
import isodate
|
|
from dateutil import parser
|
|
|
|
import ifcopenshell
|
|
|
|
|
|
def timedelta2duration(timedelta):
|
|
components = {
|
|
"days": getattr(timedelta, "days", 0),
|
|
"hours": 0,
|
|
"minutes": 0,
|
|
"seconds": getattr(timedelta, "seconds", 0),
|
|
}
|
|
if components["seconds"]:
|
|
components["hours"], components["minutes"], components["seconds"] = [
|
|
int(i) for i in str(datetime.timedelta(seconds=components["seconds"])).split(":")
|
|
]
|
|
return isodate.Duration(**components)
|
|
|
|
|
|
def ifc2datetime(element: Union[str, int, ifcopenshell.entity_instance]):
|
|
if isinstance(element, str):
|
|
if "P" in element[0:2]: # IfcDuration
|
|
duration = parse_duration(element)
|
|
if isinstance(duration, datetime.timedelta):
|
|
return timedelta2duration(duration)
|
|
return duration
|
|
elif len(element) > 3 and element[2] == ":": # IfcTime
|
|
return datetime.time.fromisoformat(element)
|
|
elif ":" in element: # IfcDateTime
|
|
return datetime.datetime.fromisoformat(element)
|
|
else: # IfcDate
|
|
return datetime.date.fromisoformat(element)
|
|
|
|
elif isinstance(element, int): # IfcTimeStamp
|
|
return datetime.datetime.fromtimestamp(element)
|
|
|
|
elif isinstance(element, ifcopenshell.entity_instance):
|
|
if element.is_a("IfcDateAndTime"):
|
|
return datetime.datetime(
|
|
element.DateComponent.YearComponent,
|
|
element.DateComponent.MonthComponent,
|
|
element.DateComponent.DayComponent,
|
|
element.TimeComponent.HourComponent,
|
|
element.TimeComponent.MinuteComponent,
|
|
int(element.TimeComponent.SecondComponent),
|
|
# TODO: implement TimeComponent timezone
|
|
)
|
|
elif element.is_a("IfcCalendarDate"):
|
|
return datetime.date(
|
|
element.YearComponent,
|
|
element.MonthComponent,
|
|
element.DayComponent,
|
|
)
|
|
|
|
|
|
def readable_ifc_duration(duration: str) -> str:
|
|
"""Convert ISO duration to more readable string format.
|
|
|
|
Examples:
|
|
- "P2Y3M1W4DT5H45M30S" -> "2 Y 3 M 1 W 4 D 5 h 45 m 30 s"
|
|
- "P2Y3MT30S" -> "2 Y 3 M 30 s"
|
|
- "PT2500H" -> "2500 h" (hours are not converted to days)
|
|
"""
|
|
# NOTE: we don't use isodate.parseduration as it's going to
|
|
# represent "PT2500H" as "12w 6d 4h", though user may want
|
|
# intentionally to use just hours.
|
|
|
|
if "T" in duration:
|
|
period_duration, time_duration = duration.split("T")
|
|
period_duration = period_duration[1:]
|
|
else:
|
|
period_duration = duration[1:]
|
|
time_duration = ""
|
|
|
|
result: list[str] = []
|
|
for designator in ("Y", "M", "W", "D"):
|
|
if designator in period_duration:
|
|
value, period_duration = period_duration.split(designator)
|
|
if float(value):
|
|
result.append(f"{value}{designator}")
|
|
|
|
if time_duration:
|
|
for designator in ("H", "M", "S"):
|
|
if designator in time_duration:
|
|
value, time_duration = time_duration.split(designator)
|
|
if float(value):
|
|
result.append(f"{value}{designator.lower()}")
|
|
return " ".join(result)
|
|
|
|
|
|
@overload
|
|
def datetime2ifc(dt: None, ifc_type: Any) -> None: ...
|
|
@overload
|
|
def datetime2ifc(
|
|
dt: Union[datetime.date, str, None],
|
|
ifc_type: Literal[
|
|
"IfcDuration",
|
|
"IfcTimeStamp",
|
|
"IfcDateTime",
|
|
"IfcDate",
|
|
"IfcTime",
|
|
"IfcCalendarDate",
|
|
"IfcLocalTime",
|
|
],
|
|
) -> Union[int, str, dict[str, Any], None]: ...
|
|
def datetime2ifc(
|
|
dt: Union[datetime.date, str, None],
|
|
ifc_type: Literal[
|
|
"IfcDuration",
|
|
"IfcTimeStamp",
|
|
"IfcDateTime",
|
|
"IfcDate",
|
|
"IfcTime",
|
|
"IfcCalendarDate",
|
|
"IfcLocalTime",
|
|
],
|
|
) -> Union[int, str, dict[str, Any], None]:
|
|
if isinstance(dt, str):
|
|
if ifc_type == "IfcDuration":
|
|
return dt
|
|
try:
|
|
dt = datetime.datetime.fromisoformat(dt)
|
|
except:
|
|
dt = datetime.time.fromisoformat(dt)
|
|
elif dt is None:
|
|
return
|
|
|
|
if ifc_type == "IfcDuration":
|
|
return isodate.duration_isoformat(dt)
|
|
elif ifc_type == "IfcTimeStamp":
|
|
return int(dt.timestamp())
|
|
elif ifc_type == "IfcDateTime":
|
|
if isinstance(dt, datetime.datetime):
|
|
return dt.isoformat()
|
|
elif isinstance(dt, datetime.date):
|
|
return datetime.datetime.combine(dt, datetime.datetime.min.time()).isoformat()
|
|
elif ifc_type == "IfcDate":
|
|
if isinstance(dt, datetime.datetime):
|
|
return dt.date().isoformat()
|
|
elif isinstance(dt, datetime.date):
|
|
return dt.isoformat()
|
|
elif ifc_type == "IfcTime":
|
|
if isinstance(dt, datetime.datetime):
|
|
return dt.time().isoformat()
|
|
elif isinstance(dt, datetime.time):
|
|
return dt.isoformat()
|
|
elif ifc_type == "IfcCalendarDate":
|
|
return {
|
|
"DayComponent": dt.day,
|
|
"MonthComponent": dt.month,
|
|
"YearComponent": dt.year,
|
|
}
|
|
elif ifc_type == "IfcLocalTime":
|
|
# TODO implement timezones
|
|
return {
|
|
"HourComponent": dt.hour,
|
|
"MinuteComponent": dt.minute,
|
|
"SecondComponent": dt.second,
|
|
}
|
|
|
|
raise TypeError(f"Unsupported ifc_type for conversion from datetime.datetime = {ifc_type}, value = {dt}")
|
|
|
|
|
|
def string_to_date(string):
|
|
if not string:
|
|
return None
|
|
try:
|
|
return parser.isoparse(string)
|
|
except:
|
|
try:
|
|
return parser.parse(string, dayfirst=True, fuzzy=True)
|
|
except:
|
|
return None
|
|
|
|
|
|
def string_to_duration(duration_string):
|
|
# TODO support years, months, weeks aswell
|
|
days = 0
|
|
hours = 0
|
|
minutes = 0
|
|
seconds = 0
|
|
match = findall(r"(\d+\.?\d*)d", duration_string)
|
|
if match:
|
|
days = float(match[0])
|
|
match = findall(r"(\d+\.?\d*)h", duration_string)
|
|
if match:
|
|
hours = float(match[0])
|
|
match = findall(r"(\d+\.?\d*)m", duration_string)
|
|
if match:
|
|
minutes = float(match[0])
|
|
match = findall(r"(\d+\.?\d*)s", duration_string)
|
|
if match:
|
|
seconds = float(match[0])
|
|
return isodate.duration_isoformat(datetime.timedelta(days=days, hours=hours, minutes=minutes, seconds=seconds))
|
|
|
|
|
|
def parse_duration(value: Union[str, None]) -> Union[datetime.timedelta, None]:
|
|
if not value:
|
|
return None
|
|
if isinstance(value, str):
|
|
if "P" in value:
|
|
try:
|
|
return isodate.parse_duration(value)
|
|
except:
|
|
print("Error parsing ISO string duration")
|
|
return None
|
|
else:
|
|
try:
|
|
final_string = "P"
|
|
value_upper = value.upper()
|
|
for char in value_upper:
|
|
if char.isdigit():
|
|
final_string += char
|
|
elif char == "D":
|
|
final_string += "D"
|
|
if "H" in value_upper or "S" in value_upper or "MIN" in value_upper:
|
|
final_string += "T"
|
|
elif char == "W":
|
|
final_string += "W"
|
|
elif char == "M":
|
|
final_string += "M"
|
|
elif char == "Y":
|
|
final_string += "Y"
|
|
elif char == "H":
|
|
final_string = (
|
|
final_string[:1] + "T" + final_string[1:] if "T" not in final_string else final_string
|
|
)
|
|
final_string += "H"
|
|
elif char == "M":
|
|
if "MIN" in value_upper and "T" not in final_string:
|
|
final_string = final_string[:1] + "T" + final_string[1:]
|
|
final_string += "M"
|
|
elif char == "S":
|
|
final_string = (
|
|
final_string[:1] + "T" + final_string[1:] if "T" not in final_string else final_string
|
|
)
|
|
final_string += "S"
|
|
return isodate.parse_duration(final_string)
|
|
except:
|
|
print("error fuzzy parsing duration")
|
|
return None
|
|
|
|
|
|
def canonicalise_time(time: Union[datetime.datetime, None]) -> str:
|
|
if not time:
|
|
return "-"
|
|
return time.strftime("%d/%m/%y")
|