feat(848-6): 불러오기 원문 단위 · Q 값 글자 Q 부름 · STmate 기계 단위 X → 시간 · 단위 정규화 대문자
- 가져온 식 문서 derive 끝 `M02_Doc_Import_Q.tidy` (새 파일) — 원문 글줄(mid:) 단위 글 → 빈 변수 단위 (짐작 없음 · 낱말 목록 밖 안 닮) · 기계 밖 줄 나눔 자리 수 = Q 값이고 뜻 분명할 때만 Q 부름 · 아니면 「참고 · Q 값 글자」 표지 - STmate 원파일 기계 단위 기호 「X」 → 「시간」 (엑셀 내보내기와 같음 · 호표 · 자원 단위) - `norm_unit` ↔ `normUnit` 대문자 M3 · M2 · M · HR · TON (기존 입력 결과 그대로) - 전수 3,241 블록 — 엑셀 단가 그대로 · 우리 단가로 계 · 비목 · 검산 전후 다름 0 · 작업량 줄 블록 715 → 1,634 · Q 단위 2,324 / 2,362 · Q 글자 바꾼 블록 32 · 단위 X 667 → 0 · 그리기 규칙 지킴 전후 같음 - 세 줄 합침 · 겹분수는 안 고침 (848-7 · 화면 몫 — 보고) - 시험 test_848_6_import_q 30 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -20,6 +20,7 @@ from decimal import Decimal
|
||||
from typing import Any
|
||||
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
from M02_MasterTemplete import M02_Doc_Import_Q as qt
|
||||
from M02_MasterTemplete import M02_Doc_Import_Shape as shape
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_San_MatPick as mp
|
||||
@@ -452,6 +453,7 @@ def derive(sk: dict, ctx: tuple | None = None, whole: Any = None) -> dict:
|
||||
if mats: # 827-3 재료 찾기 판정(줄 쌓기 풍선말 · 이미 만든 SK 고름 얹기)
|
||||
alive = {dc.md.var_id(v) for v in doc.get("변수") or []}
|
||||
doc["가져온"]["재료"] = [x for x in mats if x["기호"] in alive]
|
||||
qt.tidy(doc, meta) # 848-6 원문 단위 · Q 값 글자
|
||||
return {**doc, "키": str(sk.get("키") or key), "이름": str(sk.get("이름") or doc.get("이름"))}
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,220 @@
|
||||
"""M02 가져온 식 문서 — 원문 단위 · Q 값 글자(PLAN 848-6 · 요구 889) — 금액 그대로.
|
||||
|
||||
`M02_Doc_Import.derive` 끝에 부름(서버 단독).
|
||||
① 변수 단위 = 원문 글줄(자리 `mid:이름` · `자리들`)의 단위 글 —
|
||||
EST 「= 23.39 ㎥/hr」 「20sec (135˚)」 · STmate 「='m3/hr'」 「20 'sec(135)'」 · 괄호 덧말 뗌 ·
|
||||
단위 글 없음 · 못 읽음 = 안 닮(짐작 없음) · 이미 단위 있는 변수는 그대로 ·
|
||||
표기 = `master_doc_work.norm_unit`(엔진이 「…/hr」 로 작업량 자리를 읽음)
|
||||
② 기계 밖 줄 수량의 Q 값 글자(「1 ÷ 8 ÷ 23.39」) → Q 부름(「1 ÷ 8 ÷ Q」) —
|
||||
나눔 자리 수(괄호 속 사슬 포함 「3 ÷ (63 ÷ 2)」) = 기계 줄 수량이 나누는 변수(Q) 값과 꼭 같음 ·
|
||||
같은 값 변수가 그 Q 하나 · 8(시간) 아님 · 그 글자가 줄에 하나 ·
|
||||
그 줄이 Q 나 Q 사슬 변수를 안 부름 · 아니면 그대로 두고 「참고 · …」 표지(판정 칠 밖)
|
||||
경쟁사 식 · 변수 이름 · 글 줄 · 로직 층(검산)은 안 고침.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from decimal import Decimal
|
||||
from typing import Any
|
||||
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
|
||||
md, mw = dc.md, dc.mw
|
||||
_ATOM = (
|
||||
r"\d*(?:㎥|㎡|㎞|㎝|㎜|㎏|ℓ|m3|m2|km|cm|mm|m|hr|h|min|sec|ton|kg|ea|set|a|l|t|"
|
||||
r"시간|일|분|초|회|대|인|개소|개|본|톤|주|매|공|조|기|장|쌍|그루)"
|
||||
)
|
||||
_UNIT = re.compile(rf"^{_ATOM}(?:/{_ATOM})*$", re.I)
|
||||
_HEAD = re.compile(r"(?<![\w.'])([A-Za-z][A-Za-z0-9_]*)\s*(?:'[^']*'\s*)?=(?!=)")
|
||||
_LEAD = re.compile(r"^[\s\-+]*[\d,]*\.?\d*\s*")
|
||||
_NUM = re.compile(r"(?<![\w.])\d+(?:\.\d+)?(?![\w.])")
|
||||
NOTE = "참고 · Q 값 글자 — "
|
||||
|
||||
|
||||
def _unit(raw: str) -> str:
|
||||
"""단위 글 후보 → 단위 | 빈 글 — 괄호 · {} 덧말 · <> 뗌 · 「:」 「,」 뒤 설명 뗌 ·
|
||||
낱말 목록(`_ATOM`) 밖 = 빈 글."""
|
||||
s = re.sub(r"\([^)]*\)?|\{[^}]*\}?|[<>\[\]]", "", raw)
|
||||
s = re.split(r"[:,]", s)[0].replace(" ", "")
|
||||
return mw.norm_unit(s) if s and _UNIT.match(s) else ""
|
||||
|
||||
|
||||
def _outside(text: str) -> list[tuple[bool, str]]:
|
||||
"""글 → [(따옴표 안?, 조각)]."""
|
||||
return [(i % 2 == 1, x) for i, x in enumerate(text.split("'"))]
|
||||
|
||||
|
||||
def _tail(seg: str) -> str:
|
||||
"""대입 한 조각 → 맨 끝 「=」 뒤 단위 글(STmate = 따옴표 글 · EST = 값 뒤 글)."""
|
||||
bits = _outside(seg)
|
||||
last = max((i for i, (q, x) in enumerate(bits) if not q and "=" in x), default=None)
|
||||
if last is None:
|
||||
return ""
|
||||
after = [bits[last][1].rsplit("=", 1)[1], *(x for _, x in bits[last + 1 :])]
|
||||
quoted = [x for i, x in enumerate(after) if i % 2 == 1]
|
||||
if quoted: # 「=3.5'㎥/hr''연암'」 — 단위로 읽히는 첫 글
|
||||
return next((u for u in map(_unit, quoted) if u), "")
|
||||
return _unit(_LEAD.sub("", after[0]))
|
||||
|
||||
|
||||
def _segments(text: str, n: int) -> list[str] | None:
|
||||
"""한 글줄의 대입 n 개 조각 — STmate(따옴표) = 바깥 「,」 로 · EST = 「이름 =」 자리로 ·
|
||||
안 맞음 = None."""
|
||||
if n == 1:
|
||||
return [text]
|
||||
if "'" in text:
|
||||
parts, cur, depth = [], "", 0
|
||||
for quoted, bit in _outside(text):
|
||||
if quoted:
|
||||
cur += f"'{bit}'"
|
||||
continue
|
||||
for ch in bit:
|
||||
depth += (ch == "(") - (ch == ")")
|
||||
if ch == "," and depth == 0:
|
||||
parts.append(cur)
|
||||
cur = ""
|
||||
else:
|
||||
cur += ch
|
||||
parts = [p for p in [*parts, cur] if _HEAD.search(p)]
|
||||
return parts if len(parts) == n else None
|
||||
at = [m.start() for m in _HEAD.finditer(text)]
|
||||
return [text[a:b] for a, b in zip(at, [*at[1:], len(text)])] if len(at) == n else None
|
||||
|
||||
|
||||
def units(doc: dict, lines: list[dict]) -> int:
|
||||
"""① 원문 글줄 단위 → 빈 단위 변수 · 단 수."""
|
||||
by = {md.var_id(v): v for v in doc.get("변수") or []}
|
||||
n = 0
|
||||
for one in lines:
|
||||
spots = one.get("자리들") or [one.get("자리")]
|
||||
names = [str(s)[4:] for s in spots if str(s or "").startswith("mid:")]
|
||||
segs = _segments(str(one.get("글") or ""), len(names)) if names else None
|
||||
for name, seg in zip(names, segs or []):
|
||||
var = by.get(name)
|
||||
got = _tail(seg) if var is not None and not var.get("단위") else ""
|
||||
if got:
|
||||
var["단위"] = got
|
||||
n += 1
|
||||
return n
|
||||
|
||||
|
||||
# ── ② Q 값 글자 ────────────────────────────────────────────────────────
|
||||
def _parse(text: Any):
|
||||
try:
|
||||
return md.parse(str(text))
|
||||
except Exception: # noqa: BLE001 — 못 읽는 식 = 건너뜀
|
||||
return None
|
||||
|
||||
|
||||
def _dividers(node, kind: str = "var", sign: int = 1, out: list | None = None) -> list:
|
||||
"""곱 · 나눔 사슬(괄호 속 사슬까지)에서 나누는 변수 이름 | 수(kind = var | num)."""
|
||||
out = [] if out is None else out
|
||||
if node and node[0] == "bin" and node[1] in ("*", "/"):
|
||||
_dividers(node[2], kind, sign, out)
|
||||
_dividers(node[3], kind, -sign if node[1] == "/" else sign, out)
|
||||
elif node and node[0] == kind and sign < 0:
|
||||
out.append(node[1])
|
||||
return out
|
||||
|
||||
|
||||
def _chain(doc: dict, name: str, seen: set) -> set:
|
||||
"""Q 정의 식이 부르는 변수(거슬러 올라감)."""
|
||||
line = next((x for x in doc.get("식") or [] if x.get("기호") == name), None)
|
||||
node = _parse(line.get("식")) if line else None
|
||||
for n in md.names(node) if node else []:
|
||||
if n not in seen:
|
||||
seen.add(n)
|
||||
_chain(doc, n, seen)
|
||||
return seen
|
||||
|
||||
|
||||
def _values(doc: dict) -> dict:
|
||||
"""수 · 식 변수만 셈(연결 없이) — Q 값."""
|
||||
bare = {k: doc.get(k) for k in ("키", "이름", "결과단위", "식", "끝수")}
|
||||
bare["변수"] = [
|
||||
v for v in doc.get("변수") or [] if (v.get("연결") or {}).get("갈래") in ("숫자", "식")
|
||||
]
|
||||
bare["금액"] = []
|
||||
try:
|
||||
return dc.mc.calc(bare, None).get("값") or {}
|
||||
except Exception: # noqa: BLE001 — 못 셈 = Q 값 모름(안 바꿈)
|
||||
return {}
|
||||
|
||||
|
||||
def _dec(v: Any) -> Decimal | None:
|
||||
"""셈 값 → 수(수 글 = 저장본 꼴 · 묶음 · 글 = None)."""
|
||||
if isinstance(v, bool) or not isinstance(v, (Decimal, int, float, str)):
|
||||
return None
|
||||
try:
|
||||
return Decimal(str(v))
|
||||
except ArithmeticError:
|
||||
return None
|
||||
|
||||
|
||||
def _two(v: Decimal) -> str:
|
||||
return f"{v:.2f}".rstrip("0").rstrip(".")
|
||||
|
||||
|
||||
def literals(doc: dict) -> list[str]:
|
||||
"""② 기계 밖 줄 Q 값 글자 → Q 부름 · 못 가름 = 표지 글 목록."""
|
||||
by = {md.var_id(v): v for v in doc.get("변수") or []}
|
||||
found = {x.get("기호") for x in (doc.get("가져온") or {}).get("기계") or []}
|
||||
money = doc.get("금액") or []
|
||||
|
||||
def machine(line: dict) -> bool:
|
||||
price = str(line.get("단가") or "").removesuffix(".계")
|
||||
link = (by.get(price) or {}).get("연결") or {}
|
||||
return price in found or (
|
||||
link.get("갈래") == "단가산출" and "기계" in (link.get("입력") or {})
|
||||
)
|
||||
|
||||
qs = list(
|
||||
dict.fromkeys(
|
||||
q for x in money if machine(x) for q in _dividers(_parse(x.get("수량") or "1"))
|
||||
)
|
||||
)
|
||||
if not qs:
|
||||
return []
|
||||
vals = {k: d for k, v in _values(doc).items() if (d := _dec(v)) is not None}
|
||||
qv = {q: vals[q] for q in qs if q in vals}
|
||||
notes = []
|
||||
for line in money:
|
||||
text = line.get("수량")
|
||||
if machine(line) or not isinstance(text, str):
|
||||
continue
|
||||
node = _parse(text)
|
||||
if node is None:
|
||||
continue
|
||||
used, spots = set(md.names(node)), {}
|
||||
for lit in dict.fromkeys(_dividers(node, "num")):
|
||||
lit = Decimal(lit)
|
||||
same = [q for q, v in qv.items() if v == lit]
|
||||
near = [q for q, v in qv.items() if _two(v) == _two(lit)]
|
||||
if not same and not near:
|
||||
continue
|
||||
at = [m for m in _NUM.finditer(text) if Decimal(m.group(0)) == lit]
|
||||
others = [n for n, v in vals.items() if v == lit and n not in qv] # 같은 값 다른 변수
|
||||
ok = len(same) == 1 and not others and lit != mw.EIGHT and len(at) == 1
|
||||
ok = ok and not (used & _chain(doc, same[0], {same[0]}))
|
||||
if ok:
|
||||
spots[at[0].span()] = same[0]
|
||||
continue
|
||||
why = "Q 여럿" if len(same) > 1 else "끝수 다름" if not same else "뜻 불분명"
|
||||
why = f"같은 값 변수 {others[0]}" if others and same else why
|
||||
why = "같은 글자 여럿" if len(at) > 1 and why == "뜻 불분명" else why
|
||||
who = f"{at[0].group(0) if at else lit} = {(same or near)[0]} 값"
|
||||
notes.append(f"{NOTE}「{line.get('이름')}」 수량 {text} 의 {who} · {why}")
|
||||
for (a, b), q in sorted(spots.items(), reverse=True):
|
||||
text = text[:a] + q + text[b:]
|
||||
line["수량"] = text
|
||||
return notes
|
||||
|
||||
|
||||
def tidy(doc: dict, meta: dict) -> None:
|
||||
"""derive 끝 — ① 단위 ② Q 글자(표지 = `가져온.표지` 뒤)."""
|
||||
units(doc, list((meta.get("원본") or {}).get("글줄") or []))
|
||||
notes = literals(doc)
|
||||
if notes:
|
||||
head = doc.setdefault("가져온", {})
|
||||
head["표지"] = [*(head.get("표지") or []), *notes]
|
||||
@@ -40,6 +40,7 @@ RESERVED |= {"또는", "만약", "올림", "버림", "반올림", "최소", "최
|
||||
_KEY = re.compile(r"[A-Z]{2}\d{6}")
|
||||
_LABEL = re.compile(r"'([^']*)'")
|
||||
NOTE = "참고 · " # 사람 확인 표지 머리(못 옮김 표지와 가름)
|
||||
HOUR = "시간" # 848-6 STmate 원파일 기계 단위 기호 「X」 = 엑셀 내보내기 「시간」
|
||||
|
||||
|
||||
class EmitError(Exception):
|
||||
@@ -409,7 +410,8 @@ class _Stm:
|
||||
self.fix.append((one, len(self.order)))
|
||||
return self.line(one, node, False, src)
|
||||
res = {"꼴": "STmate", "갈래": KIND.get(code[0], "고정"), "코드": code}
|
||||
res |= {k: pr.get(k) for k in ("이름", "규격", "단위")}
|
||||
unit = HOUR if code[0] == "X" and pr.get("단위") == "X" else pr.get("단위")
|
||||
res |= {k: pr.get(k) for k in ("이름", "규격")} | {"단위": unit}
|
||||
res |= {"단가": {c: pr.get(c) or 0 for c in COMP}}
|
||||
sole = [c for c in COMP if res["단가"][c]]
|
||||
if not one_ and len(sole) == 1: # 비목 꼬리 없어도 값 든 비목 하나면 단가 줄(셈 같음)
|
||||
@@ -423,7 +425,7 @@ class _Stm:
|
||||
res |= {"조합첫": True} if len(parts) > 1 else {}
|
||||
else:
|
||||
link, many = _m01(res["갈래"], res, _label(node)) if self.keys else (None, None)
|
||||
one = first_spec(resource(o.names.item(name), pr.get("단위"), cf, res, link), parts)
|
||||
one = first_spec(resource(o.names.item(name), unit, cf, res, link), parts)
|
||||
if parts and one["종류"] == "로직":
|
||||
one["이음"] = combo_link(one, parts) or hourly_text(link)
|
||||
self.line(one, node, True, src)
|
||||
|
||||
@@ -84,8 +84,9 @@ type Fac = [number, Node];
|
||||
export const normUnit = (u: unknown): string =>
|
||||
String(u ?? "")
|
||||
.trim()
|
||||
.replace(/m3/g, "㎥")
|
||||
.replace(/m2/g, "㎡")
|
||||
.replace(/[mM]3/g, "㎥") // 848-6 대문자 꼴
|
||||
.replace(/[mM]2/g, "㎡")
|
||||
.replace(/(?<![A-Za-z])(M|HR|Hr|TON|Ton)(?![A-Za-z])/g, (s) => s.toLowerCase())
|
||||
.replace(/\/(시간|h|Hr|HR)$/, "/hr");
|
||||
|
||||
const varOf = (doc: FormulaDoc, name: string): DocVar | undefined =>
|
||||
|
||||
@@ -33,7 +33,8 @@ EIGHT = Decimal(8)
|
||||
|
||||
|
||||
def norm_unit(u) -> str:
|
||||
t = str(u or "").strip().replace("m3", "㎥").replace("m2", "㎡")
|
||||
t = re.sub(r"[mM]3", "㎥", re.sub(r"[mM]2", "㎡", str(u or "").strip())) # 848-6 대문자 꼴
|
||||
t = re.sub(r"(?<![A-Za-z])(M|HR|Hr|TON|Ton)(?![A-Za-z])", lambda m: m.group(1).lower(), t)
|
||||
return re.sub(r"/(시간|h|Hr|HR)$", "/hr", t)
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,206 @@
|
||||
"""848-6 불러오기 — 원문 단위 · Q 값 글자 · STmate 기계 단위 X(서버 단독 · 금액 그대로).
|
||||
|
||||
① 원문 글줄 단위 글 읽기(EST · STmate 꼴 · 못 읽음 = 빈 글) ② 단위 정규화 대문자 꼴 파이썬 = TS 거울
|
||||
③ Q 값 글자 → Q 부름(값 같고 뜻 분명할 때만 · 아니면 「참고 · …」 표지) ④ 실제 원파일 견본 셋 —
|
||||
Q 단위 · 시간당 작업량 줄 · 기계 줄 단위 「시간」 · 엑셀 단가 그대로 계 = 원파일 · 검산 같음.
|
||||
원파일 없으면 ④ 만 skip(다른 PC).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import subprocess
|
||||
import sys
|
||||
from decimal import Decimal as D
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
HERE = Path(__file__).resolve().parent
|
||||
for p in (ROOT, HERE):
|
||||
if str(p) not in sys.path:
|
||||
sys.path.insert(0, str(p))
|
||||
|
||||
import test_810_2_native_doc as nd # noqa: E402
|
||||
|
||||
from M02_MasterTemplete import M02_Doc_FromNative as fn # noqa: E402
|
||||
from M02_MasterTemplete import M02_Doc_Import as dim # noqa: E402
|
||||
from M02_MasterTemplete import M02_Doc_Import_Q as qt # noqa: E402
|
||||
from M02_MasterTemplete import M02_Sangeun_Imported as imp # noqa: E402
|
||||
|
||||
|
||||
# ── ① 원문 단위 글 ───────────────────────────────────────────────────────
|
||||
@pytest.mark.parametrize(
|
||||
"text, n, want",
|
||||
[
|
||||
(" Q = ────────── = ─────────────── = 23.39 ㎥/hr", 1, ["㎥/hr"]),
|
||||
(" E = 0.45 Cm = 20sec (135˚)", 2, ["", "sec"]),
|
||||
(" Q = 560㎥ / 8hr = 70㎥/hr", 1, ["㎥/hr"]),
|
||||
(" Q = 8. hr / (63. ㎥×0.5) = 0.254 hr/㎥", 1, ["hr/㎥"]),
|
||||
("Q = 3600*q*k*E*f/Cm ='m3/hr'", 1, ["㎥/hr"]),
|
||||
(" Q1 = 60 * q1 * F * E / Cm ='M3/HR'", 1, ["㎥/hr"]),
|
||||
("Cm = 20 'sec(135)'", 1, ["sec"]),
|
||||
(" t3 = 1.5 , t4 = 0.7", 2, ["", ""]),
|
||||
("q'(버킷용량)' = 1.0 , k'(버킷계수)' = 0.55 , E'(작업효율)' = 0.45", 3, ["", "", ""]),
|
||||
(" Cm = 20'sec (135˚)', E = 0.75", 2, ["sec", ""]),
|
||||
(" Q=3.5'㎥/hr''연암'", 1, ["㎥/hr"]),
|
||||
(" Q = Qt / t / 100㎡ = 1.95 / 0.05 / 100 = 0.39 a/hr", 1, ["a/hr"]),
|
||||
(" L = 0.5km {작업능력}", 1, ["km"]),
|
||||
(" '□ 시간당 시공량 :' Q = 63'm3/일r'", 1, [""]), # 원문 오타 = 못 읽음(짐작 안 함)
|
||||
("K = 0.9 '보통'", 1, [""]),
|
||||
(" Q = 17개 ÷ 8hr = 2.13", 1, [""]), # 값 뒤 단위 글 없음
|
||||
],
|
||||
)
|
||||
def test_원문_단위_글(text, n, want):
|
||||
segs = qt._segments(text, n)
|
||||
assert segs is not None and [qt._tail(s) for s in segs] == want
|
||||
|
||||
|
||||
def test_대입_수_안_맞으면_안_닮():
|
||||
assert qt._segments("q = 0.7 K = 0.55", 3) is None
|
||||
|
||||
|
||||
def _var(name, link, unit=""):
|
||||
return {"열쇠": name, "기호": name, "아래": "", "이름": name, "단위": unit, "연결": link}
|
||||
|
||||
|
||||
def test_단위_닮_빈_칸만():
|
||||
doc = {"변수": [_var("Q", {"갈래": "식"}), _var("Cm", {"갈래": "숫자", "값": D(20)}, "초")]}
|
||||
lines = [{"글": " E = 0.45 Cm = 20sec", "자리": "mid:E", "자리들": ["mid:E", "mid:Cm"]},
|
||||
{"글": " Q = ── = 23.39 ㎥/hr", "자리": "mid:Q"}] # fmt: skip
|
||||
assert qt.units(doc, lines) == 1
|
||||
assert [v["단위"] for v in doc["변수"]] == ["㎥/hr", "초"] # 이미 있는 단위 그대로
|
||||
|
||||
|
||||
# ── ② 정규화 거울 ────────────────────────────────────────────────────────
|
||||
NORM = [
|
||||
"M3/HR",
|
||||
"m3/hr",
|
||||
"M2/Hr",
|
||||
"M/HR",
|
||||
"TON/HR",
|
||||
"Ton",
|
||||
"㎥/hr",
|
||||
"m/시간",
|
||||
"100m2",
|
||||
"MIN",
|
||||
"EA/hr",
|
||||
]
|
||||
_JS = r"""
|
||||
const fs = require("fs"), path = require("path");
|
||||
const ts = require(path.join(process.argv[1], "config", "node_modules", "typescript"));
|
||||
const cache = new Map();
|
||||
function load(at) {
|
||||
if (cache.has(at)) return cache.get(at);
|
||||
const js = ts.transpileModule(fs.readFileSync(at, "utf8"), {
|
||||
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
|
||||
}).outputText;
|
||||
const box = { exports: {} };
|
||||
cache.set(at, box.exports);
|
||||
const need = (p) => (p.startsWith(".") ? load(path.resolve(path.dirname(at), `${p}.ts`)) : require(p));
|
||||
new Function("exports", "module", "require", js)(box.exports, box, need);
|
||||
return box.exports;
|
||||
}
|
||||
const work = load(path.join(process.argv[1], "common_util", "common_util_formula_doc_work.ts"));
|
||||
const xs = JSON.parse(fs.readFileSync(0, "utf8"));
|
||||
process.stdout.write(JSON.stringify(xs.map(work.normUnit)));
|
||||
"""
|
||||
|
||||
|
||||
def test_정규화_대문자_파이썬_TS_같음():
|
||||
want = [qt.mw.norm_unit(x) for x in NORM]
|
||||
assert want == ["㎥/hr", "㎥/hr", "㎡/hr", "m/hr", "ton/hr", "ton", "㎥/hr", "m/hr", "100㎡", "MIN", "EA/hr"] # fmt: skip
|
||||
proc = subprocess.run(["node", "-e", _JS, str(ROOT)], input=json.dumps(NORM), capture_output=True,
|
||||
text=True, encoding="utf-8", check=True) # fmt: skip
|
||||
assert json.loads(proc.stdout) == want
|
||||
|
||||
|
||||
# ── ③ Q 값 글자 ─────────────────────────────────────────────────────────
|
||||
def _doc(vars_, crew, defs=()):
|
||||
return {
|
||||
"키": "SK-999999", "이름": "시험", "결과단위": "원/㎥",
|
||||
"변수": [*vars_, _var("P_굴", {"갈래": "숫자", "값": {"노무비": D(1), "재료비": D(1), "경비": D(1)}}),
|
||||
_var("P_인", {"갈래": "숫자", "값": D(100)})],
|
||||
"식": [{"기호": k, "식": v} for k, v in defs],
|
||||
"금액": [{"이름": "굴삭기", "비목": "묶음", "수량": "1 ÷ Q", "단가": "P_굴"},
|
||||
{"이름": "보통인부", "비목": "노무비", "수량": crew, "단가": "P_인"}],
|
||||
"가져온": {"기계": [{"기호": "P_굴"}]},
|
||||
} # fmt: skip
|
||||
|
||||
|
||||
NUM = {"갈래": "숫자", "값": D("23.39")}
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"crew, want",
|
||||
[("1 ÷ 8 ÷ 23.39 × 0.1", "1 ÷ 8 ÷ Q × 0.1"), ("3 ÷ (23.39 ÷ 2)", "3 ÷ (Q ÷ 2)")],
|
||||
)
|
||||
def test_Q_글자_값_같으면_Q_부름(crew, want):
|
||||
doc = _doc([_var("Q", NUM)], crew)
|
||||
assert qt.literals(doc) == []
|
||||
assert doc["금액"][1]["수량"] == want
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"vars_, crew, defs, why",
|
||||
[
|
||||
([_var("Q", NUM), _var("t", NUM)], "1 ÷ 8 ÷ 23.39", (), "같은 값 변수 t"),
|
||||
([_var("Qd", {"갈래": "숫자", "값": D(20)}), _var("Q", {"갈래": "식"})], "1 ÷ Qd ÷ 2.5",
|
||||
(("Q", "Qd ÷ 8"),), "뜻 불분명"), # 줄이 Q 사슬(Qd)을 부름 · 2.5 = 길이
|
||||
([_var("Q", {"갈래": "숫자", "값": D(8)})], "1 ÷ 8", (), "뜻 불분명"), # 8 = 시간
|
||||
([_var("Q", {"갈래": "숫자", "값": D("23.389")})], "1 ÷ 8 ÷ 23.39", (), "끝수 다름"),
|
||||
([_var("Q", NUM)], "23.39 ÷ 23.39", (), "같은 글자 여럿"),
|
||||
],
|
||||
) # fmt: skip
|
||||
def test_Q_글자_못_가르면_그대로_표지(vars_, crew, defs, why):
|
||||
doc = _doc(vars_, crew, defs)
|
||||
notes = qt.literals(doc)
|
||||
assert doc["금액"][1]["수량"] == crew
|
||||
assert len(notes) == 1 and notes[0].startswith("참고 · ") and why in notes[0]
|
||||
|
||||
|
||||
def test_Q_글자_금액_같음():
|
||||
a = _doc([_var("Q", NUM)], "1 ÷ 8 ÷ 23.39")
|
||||
b = _doc([_var("Q", NUM)], "1 ÷ 8 ÷ 23.39")
|
||||
qt.literals(b)
|
||||
assert b["금액"][1]["수량"] == "1 ÷ 8 ÷ Q"
|
||||
x, y = qt.dc.mc.calc(a, None), qt.dc.mc.calc(b, None)
|
||||
assert x["셈됨"] and [z["금액"] for z in x["줄"]] == [z["금액"] for z in y["줄"]]
|
||||
assert x["계"] == y["계"]
|
||||
|
||||
|
||||
# ── ④ 실제 원파일 견본 ───────────────────────────────────────────────────
|
||||
def _block(kind, tag, no):
|
||||
out = fn.emit(nd.native(kind, tag), no)
|
||||
sk = nd.sk_of(out)
|
||||
doc = dim.derive(sk, None, nd.whole())
|
||||
ours = {**sk, imp.KEY: {**sk[imp.KEY], "단가기준": "우리"}}
|
||||
return out, sk, doc, dim.run(doc, sk, nd.whole()), dim.run(doc, ours, nd.whole())
|
||||
|
||||
|
||||
def _unit(doc, name):
|
||||
return next(v["단위"] for v in doc["변수"] if v["열쇠"] == name)
|
||||
|
||||
|
||||
def test_EST_굴착기형_Q_단위_보조인부_Q_부름():
|
||||
out, sk, doc, xl, ours = _block("EST", "거창", 1)
|
||||
assert _unit(doc, "Q") == "㎥/hr" and _unit(doc, "Cm") == "sec"
|
||||
assert doc["금액"][1]["수량"] == "1 ÷ 8 ÷ Q"
|
||||
assert xl["계"] == D(str(out["원본"]["엑셀금액"]["계"])) == 5323
|
||||
assert ours["줄"][0]["작업량"]["값"] == D("23.39") and ours["줄"][0]["작업량"]["식들"]
|
||||
assert imp.check(sk, nd.whole())["같음"]
|
||||
|
||||
|
||||
def test_EST_일당_꼴_단위만_달아_문서_식():
|
||||
out, sk, doc, xl, ours = _block("EST", "main", 96)
|
||||
assert doc["식"] == [{"기호": "Q", "식": "560 ÷ 8"}] and _unit(doc, "Q") == "㎥/hr"
|
||||
assert xl["계"] == 1884 and ours["줄"][0]["작업량"]["값"] == 70
|
||||
|
||||
|
||||
def test_STmate_덤프_60형_작업량_줄_기계_단위_시간():
|
||||
out, sk, doc, xl, ours = _block("STC", "봉화", 109)
|
||||
assert {x["단위"] for x in out["로직"]["호표"]} == {"시간"} # 원파일 기호 「X」 → 시간
|
||||
assert _unit(doc, "q1_2") == "㎥/hr" and _unit(doc, "t1") == "분"
|
||||
assert xl["계"] == 3796 and imp.check(sk, nd.whole())["같음"]
|
||||
assert all(z.get("작업량") for z in ours["줄"])
|
||||
Reference in New Issue
Block a user