Merge remote-tracking branch 'origin/dev' into sub_laptop_2
This commit is contained in:
@@ -118,7 +118,7 @@
|
||||
- **원문번호 칸 없음** — 원문(ESTX)이 준 품번 `M0005250505` 는 남의 번호라 이름 몫을 못 함 · 대조는 `_키대장.json` 에만 둠(조달청에서 새로 더한 줄의 조달청 번호도 같음). 로직·연결은 키로 적음.
|
||||
- 유류·전력은 뗌 — 유가·전기요금은 `재료_유가전력`(유류는 값이 비고 글뿐 · 중유는 받지 않음).
|
||||
- `재료_유가전력` · `환율_한국은행환율` 도 열 한 벌 — 키 · 원문번호 · 구분 · 상세구분 · 이름 · 규격 · 단위 · 값 · 출처 · 비고. 유가전력 `구분` = 유류 · 전력 · `상세구분` = 유류(지역 이름) · 전력(계약종별) · `규격` = 기준일(유류 수집일 · 전력 시행일). 환율은 `규격` = 기준일 · 구분·상세구분 비움.
|
||||
- 로직 호표가 자재품목 키(`MT…`)를 바로 가리키면 그 줄의 값 열 가운데 낮은 값 — **시험 계산용**.
|
||||
- 재료 줄 단가 = 고른 품목(없으면 자동값 줄)의 값 열 가운데 낮은 값 — **시험 계산용**.
|
||||
- `재료_품셈재료`(PLAN 7-4b 뒤 절반 — `old/` 로 옮김 · 살아 있는 마스터엔 안 읽힘 · 자료로만 둠) = 품셈이 부르는 재료 목록이던 것 — `{ 키, 원문번호, 이름, 규격, 단위, 요구절: [출처 모양], 연결, 고르기 }` · 값 칸 없음. 로직 호표·덧줄의 `MP…` 직접 참조는 다 걷어 자재품목 고르기 조건(7장)이나 대표 키로 바꿈 — 아래 두 줄은 그 옮기던 때의 자취.
|
||||
- `연결` = 자재품목·유가전력 키 하나 · 후보 조건 `{ 이름, 규격, 지역: "입력" }`(지역이 갈리는 레미콘·골재·아스콘) · `{ 이름, 계약종별: "입력" }`(전력 — 로직 입력 `전력 계약종별`) · `null`(못 이음). 이 지역·계약종별 조건 묶음은 이제 7장의 고르기 조건(`PICK_KEYS` 의 `지역`·`계약종별`)에 그대로 들어가 호표에 바로 박힘 — 품셈재료 간접 없이 `master_material._region`·`_tariff` 가 품.
|
||||
- 단가 = 연결된 줄의 값 열 다섯 가운데 낮은 값 · 호표 결과 줄에 `출처`(`<키>.<열>`) — **시험 계산용**. 후보 조건 = 품명 뿌리가 `이름` 으로 끝남 · 이름에 로직 입력 `자재지역` 글자 · 단위 같음 · 규격이 둘 이상 갈리면 멈춤 「후보 여럿」 · 그 지역 줄이 없으면 가까운 시군을 고르지 않고 멈춤 「지역 값 없음」.
|
||||
@@ -209,7 +209,7 @@
|
||||
```json
|
||||
{
|
||||
"종류": "재료",
|
||||
"요소": { "구분": "관·수로", "상세구분": "흄관", "규격": "D300", "대표": "MT012345" },
|
||||
"요소": { "구분": "관·수로", "상세구분": "흄관", "검색어": "흄관 D300" },
|
||||
"이름": "흄관",
|
||||
"단위": "m",
|
||||
"수량": "1",
|
||||
@@ -218,17 +218,20 @@
|
||||
}
|
||||
```
|
||||
|
||||
- 조건 칸 = `구분`(반드시 — `지역`·`계약종별` 조건은 예외) · `상세구분` · `이름` · `규격` · `대표` · `지역`("입력" 만) · `계약종별`("입력" 만) · 그 밖의 칸은 두지 않음. `종류` 는 「재료」만.
|
||||
- 조건 칸 = `검색어` · `구분` · `상세구분` · `이름` · `규격` · `지역`("입력" 만) · `계약종별`("입력" 만) · 그 밖의 칸은 두지 않음. `대표` 칸은 두지 않음. `종류` 는 「재료」만.
|
||||
- `지역`·`계약종별` 조건(PLAN 7-4b 뒤 절반) = 구분·상세구분 없이 `이름` 하나로 자재품목(지역)·유가전력(계약종별)을 넓게 찾음 — 옛 품셈재료 `연결` 묶음과 같은 모양·같은 매칭(`master_material._region`·`_tariff`) · 로직 입력 `자재지역`·`전력 계약종별` 이 계산 때 좁힘 · 값은 `null`(지역·전력 마스터에 안 굳힘).
|
||||
- 구분·상세구분 = 자재품목 줄의 같은 이름 칸과 똑같이 적음(묶음 목록은 `ref/_묶음_자재품목.md`).
|
||||
- 규격 조건 = 원문이 규격을 밝힌 것만 좁힘 — 낱말이 **모두** 든 줄이 후보(「D300」 · 「D300 B종」) · 대소문자·빈칸·`φ` 는 안 가림. 원문이 규격을 안 밝히면 칸을 두지 않음.
|
||||
- 이름 조건 = 구분·상세구분·규격이 같아도 품명이 갈리는 자재품목을 가를 때만 둠(예: 파형강관 커플링밴드 vs 접속티 — 둘 다 관경만 규격에 있어 규격 조건으로는 안 갈림). 규격과 같은 방식(낱말이 **모두** 이름에 든 줄) — 대소문자·빈칸은 안 가림.
|
||||
- 대표 줄 = 관리자가 고른 자재품목 키 — 시험 계산이 그 줄의 값을 씀. 조건 밖 키는 검사가 잡음.
|
||||
- 후보는 **호표 줄 단위와 같은 자재품목 줄만** — 단위가 다르면 다른 물건(우드칩 ㎥ · 원목후로링 ㎡). 조건 안 줄이 모두 다른 단위면 `check_master 단위` 가 알림.
|
||||
- **키를 못 박음** — 재료 줄은 늘 요소 묶음 + `검색어`(「합판(내수) 12t 서울」) · 줄에 자재품목 키를 바로 적지 않음 · 재료 입력에 키 목록(`고르기`)을 두지 않음.
|
||||
- 찾기 = 검색어 낱말(띄어쓰기로 나눔)이 **모두** 이름 또는 규격에 든 자재품목 줄 · 요소에 `구분` · `상세구분` 이 있으면 그 안에서만 · 단위는 같은 성격까지(아래 환산).
|
||||
- 자동값 차례 = 값 있는 줄 → 줄 단위와 똑같은 단위 → 검색어 안 지역 낱말(서울 등)과 맞는 줄 → 키 차례 · 그 첫째.
|
||||
- 고른 품목 = 계산 요청에만 실음(`_화면_계약.md` 10장 `고름`) · 로직 파일에 저장하지 않음 · 폐기 품목은 지움.
|
||||
- 단위 환산 = 같은 성격만 — 무게 g · kg · ton(톤 · Ton) / 길이 mm · cm · m · km / 넓이 ㎠ · ㎡ / 부피 ㎤ · ℓ · ㎥ · 단가를 줄 단위로 바꿔 계산.
|
||||
- 단위 경고 = 성격이 다르면 막지 않음 — 계산은 하되 `/calc` 줄에 `단위경고` · `check_master` 가 검색어 후보 0 · 단위 경고 줄을 셈.
|
||||
- 조건 값에 `{입력}` 을 넣을 수 있음 — `"규격": "{관경}"` 은 계산 때 입력값으로 채워짐(검사에서는 그 칸을 뺌).
|
||||
- 대표가 없으면 시험 계산은 **조건 안 값 있는 첫 줄** · 로직 입력 `자재지역` 이 있으면 이름에 그 지역이 든 줄부터(레미콘·골재처럼 지역이 갈리는 품목).
|
||||
- 실제 줄 고르기는 프로젝트 몫 — 후보 목록은 `GET /api/m01/materials`(화면·테스트 컨테이너가 같이 씀).
|
||||
- 옛 방식(자재품목 키를 호표에 바로 적은 `MT…`)도 그대로 돎 — 그 줄은 그 자재품목 줄 값을 바로 씀. 품셈재료 간접(`MP…`)은 PLAN 7-4b 뒤 절반에서 다 걷음(위 4장) — 남았던 22줄(색소·에폭시·버너·퓨즈 등)도 자재품목 새 줄이나 대표 키로 이음.
|
||||
- 기계 = 입력값에 원문 분류번호(목록 밖 번호도 기계 마스터에 있으면 받음) · 기본값 = 원문 분류번호 목록 첫째 · 인력은 고르지 않음(지정값).
|
||||
|
||||
- 근거가 덜 선 줄은 `비고` 칸에 적음 — 「환산 근거 미확인」.
|
||||
- 입력 칸 = `이름`(반드시) · `설명` · `단위` · `고르기`·`범위`(둘 중 하나까지) · `출처`(원문 절) · `비고` · `시험입력`은 줄 머리에 따로.
|
||||
@@ -241,7 +244,7 @@
|
||||
## 8. 변수 · 식
|
||||
|
||||
- 요소 — 키 `LB000123` · 값 묶음은 `.칸` — `EQ000045.주연료`.
|
||||
- 입력·중간 값으로 요소를 고르면 `ID:원문번호` 에 `{이름}` 을 끼움 — `EQ:{기계}.가격` · `MO:경유:{지역}` · `LB:{조종원직종}`. 끼운 값이 키여도 됨 — `MT:{철선}` 의 고르기는 키 목록. 번호가 겹치는 표·로직은 `ID:원문번호` 로 못 부름 — 키로 적음.
|
||||
- 입력·중간 값으로 요소를 고르면 `ID:원문번호` 에 `{이름}` 을 끼움 — `EQ:{기계}.가격` · `MO:경유:{지역}` · `LB:{조종원직종}`. 재료는 `MT:{…}` 로 고르지 않음 — 7장 검색어. 번호가 겹치는 표·로직은 `ID:원문번호` 로 못 부름 — 키로 적음.
|
||||
- 표 찾기 — `찾기(QF000041, 뒷길이=뒷길이, 돌=돌, 쌓기=쌓기).석공`
|
||||
- 맞는 줄이 여럿이면 찾는 값 칸이 있는 줄만 봄. 값 칸·조건 이름에 괄호·빈칸이 있으면 작은따옴표 — `.'시공량(m)'` · `'규준틀 높이'=높이`
|
||||
- 찾기·로직 인자의 글자 값은 작은따옴표 — `구분='V(다짐속도,km/hr)'` · 따옴표 없으면 이름(입력·중간).
|
||||
|
||||
@@ -47,9 +47,9 @@
|
||||
|
||||
## 3. 시험 계산
|
||||
|
||||
`POST /calc` 받음 `{key, inputs: {이름: 값}, row?, file?}` — 새 로직은 `key` ""
|
||||
`POST /calc` 받음 `{key, inputs: {이름: 값}, row?, file?, 고름?}` — 새 로직은 `key` "" · `고름` 은 10장
|
||||
|
||||
- 됨 — `{ok: true, lines: [{이름, 단위, 수량, 단가, 금액, 비목: {비목: 금액}, 출처?}], sums: {노무비, 재료비, 경비, 계}, middle: {이름: 값}}` · `출처` = 품셈재료 줄의 단가 칸
|
||||
- 됨 — `{ok: true, lines: [{이름, 단위, 수량, 단가, 금액, 비목: {비목: 금액}, 출처?, 단위경고?}], sums: {노무비, 재료비, 경비, 계}, middle: {이름: 값}}` · `출처` = 재료 줄의 단가 칸 · `단위경고` 는 10장
|
||||
- 돈 아닌 로직 — `{ok: true, result, middle}`
|
||||
- 멈춤 — `{ok: false, reason}` (200). 까닭 = 엔진 글 그대로(「입력 「돌」 없음」 · 「값 없음 — 관리자가 채울 값」 …).
|
||||
- `row` 없음 = 저장된 파일로 계산 · `row` 있음 = 그 로직만 고친 줄로 바꿔(없던 로직이면 `file` 에 더해) 메모리에서 계산 — 파일에 안 씀. 요소 값은 늘 저장된 파일.
|
||||
@@ -192,3 +192,18 @@
|
||||
- `줄` = `{차례, 로직, 메모, 이름, 원문번호, 결과단위, 구분, 상세구분, 출처, ok, 갈래, 노무비, 재료비, 경비, 계}` · 돈이 아닌 로직은 `갈래` 「결과」 와 `결과` 수 하나(비목이 없어 합계에 안 얹음).
|
||||
- 못 도는 줄은 통째로 멈추지 않고 그 줄만 `ok` false · `까닭` · `멈춤` 에 한 줄 — 나머지 줄의 합계는 그대로 냄.
|
||||
- 답 — 200 · 400(틀린 몸 · 이름 없음 · 모르는 소유) · 404(없는 키) · 409(낡은 판본) · 422 `{detail: {errors: […]}}`(검사 걸림 — 없는 로직 키 · 같은 로직 두 번 · 빈 조합 · 조합을 담음).
|
||||
|
||||
## 10. 재료 · 기계 고르기
|
||||
|
||||
재료 줄은 키 대신 기본 검색어로 품목을 찾음 — 파일 모양 · 찾기 규칙 · 자동값 차례 · 단위 환산은 `_틀.md` 7장.
|
||||
|
||||
| 무엇 | 모양 |
|
||||
| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| 고른 품목 | `/calc` · `/text` 몸에 `"고름": {"<호표 줄 차례>": "MT000019"}` · 저장 안 함 · 기계는 그 입력값에 원문 분류번호(목록 밖 번호도 기계 마스터에 있으면 받음) |
|
||||
| 단위 경고 | 성격이 다르면 계산은 하되 `/calc` 줄에 `"단위경고": "줄 m · 자재 Ton"` · 화면은 그 줄에 딱지 |
|
||||
| 모달 검색 | 재료 = 자재품목 표 · 검색 칸 = 검색어 첫 낱말(예 「합판」) · 잡힌 품목 칠함 / 기계 = 기계 표 · 검색 칸 = 기계 이름(예 「크레인(타이어)」) |
|
||||
|
||||
- `고름` 이 없거나 그 줄에 없으면 자동값(`_틀.md` 7장 차례의 첫째).
|
||||
- 고르면 다시 계산 · 고른 품목은 파일에 저장하지 않고 계산 요청에만 실음.
|
||||
- 드롭다운 고르기는 걷음 — 재료 줄 · 기계 입력의 「품목 고르기」 가 모달을 검색 칸 채워 엶(재료 컨테이너 표 재사용).
|
||||
- 인력은 고르지 않음(지정값).
|
||||
|
||||
@@ -267,6 +267,7 @@ class Master:
|
||||
if number in slot:
|
||||
self.twice.add((key[:2], number))
|
||||
slot.setdefault(number, row)
|
||||
mp.EQ.set(self.numbers.get("EQ", {})) # 기계 입력이 목록 밖 원문 분류번호도 받게
|
||||
|
||||
def get(self, ref: str) -> dict:
|
||||
tid, _, number = ref.partition(":")
|
||||
@@ -502,7 +503,7 @@ def _inputs(row: dict, given: dict) -> dict:
|
||||
pass
|
||||
if isinstance(value, (int, float)):
|
||||
value = Decimal(str(value))
|
||||
if "고르기" in spec and value not in spec["고르기"]:
|
||||
if "고르기" in spec and value not in spec["고르기"] and not mp.machine(spec, value):
|
||||
raise FormulaError(f"입력 「{name}」={value} 고르기 밖")
|
||||
if "범위" in spec:
|
||||
low, high = spec["범위"]
|
||||
@@ -547,8 +548,8 @@ def run(master: Master, ref: str, given: dict, depth: int = 0) -> dict:
|
||||
return {"결과": cut(row, value, "결과"), "중간": _shown(env)}
|
||||
sums = dict.fromkeys(COST_ITEMS, Decimal(0))
|
||||
lines = []
|
||||
for item in row.get("호표", []):
|
||||
source = why = None
|
||||
for n, item in enumerate(row.get("호표", [])):
|
||||
source = why = warn = None
|
||||
try:
|
||||
qty = evaluate(parse(item["수량"]), env, master, depth)
|
||||
except EmptyInput as e: # 비어 있는 입력을 쓰는 줄만 비움
|
||||
@@ -579,18 +580,10 @@ def run(master: Master, ref: str, given: dict, depth: int = 0) -> dict:
|
||||
lines.append(_blank_line(item, str(e)))
|
||||
continue
|
||||
# 후보 0 · 값 빈 품목은 그 줄만 단가·금액을 비우고 까닭을 닮 — 로직은 계속 · 합에서 뺌
|
||||
# (없는 키는 틀린 로직 — 지금처럼 멈춤)
|
||||
# (없는 키는 틀린 로직 — 지금처럼 멈춤) · 검색어 · 고름 · 단위 환산은 `master_pick`
|
||||
if isinstance(ref, str) and qty != 0:
|
||||
master.get(ref)
|
||||
try:
|
||||
price, source = element(master, ref, env, item.get("단위"))
|
||||
why = (
|
||||
None
|
||||
if price is not None
|
||||
else f"「{master.label(ref)}」 값 없음 — 관리자가 채울 값"
|
||||
)
|
||||
except FormulaError as e:
|
||||
price, why = None, str(e)
|
||||
price, source, why, warn = mp.priced(master, item, ref, env, n if depth == 0 else None)
|
||||
if price is None and qty == 0:
|
||||
price, why = Decimal(0), None # 안 쓰는 재료 줄 — 값이 비어도 금액 0
|
||||
split = {item["비목"]: None if price is None else qty * price}
|
||||
@@ -606,6 +599,7 @@ def run(master: Master, ref: str, given: dict, depth: int = 0) -> dict:
|
||||
"비목": split,
|
||||
**({"출처": source} if source else {}),
|
||||
**({"까닭": why} if why else {}),
|
||||
**({"단위경고": warn} if warn else {}),
|
||||
}
|
||||
)
|
||||
# 덧줄이 호표 줄 금액 하나를 빼고 더할 수 있게 — `줄.'호표 줄 이름'`(빈 줄은 뺌)
|
||||
@@ -853,3 +847,4 @@ from master_material import ( # noqa: E402, F401
|
||||
element,
|
||||
pick,
|
||||
)
|
||||
import master_pick as mp # noqa: E402 — 검색어 · 고름 · 단위
|
||||
|
||||
@@ -120,7 +120,9 @@ def static(cond: dict) -> dict:
|
||||
|
||||
def cond_text(cond: dict) -> str:
|
||||
"""고르기 조건 한 글자 열쇠 — 「구분|상세구분|규격|대표」 · 화면 단가 미리보기가 줄을 찾는 이름."""
|
||||
return "|".join(str(cond.get(k) or "") for k in PICK_KEYS)
|
||||
return "|".join(str(cond.get(k) or "") for k in PICK_KEYS) + (
|
||||
f"|{cond['검색어']}" if cond.get("검색어") else ""
|
||||
)
|
||||
|
||||
|
||||
def by_class(master: mf.Master) -> dict[str, dict]:
|
||||
@@ -140,7 +142,10 @@ def candidates(
|
||||
) -> list[str]:
|
||||
"""고르기 조건 안 자재품목 키 — 구분 · 상세구분 · 이름 · 규격 낱말이 모두 든 줄 · 파일 차례대로.
|
||||
`unit` 을 주면 그 단위(호표 줄 단위)와 같은 줄만 — 단위가 다르면 다른 물건.
|
||||
입력 `자재지역` 이 있으면 이름에 그 지역이 든 줄만(그런 줄이 없으면 조건 안 전부)."""
|
||||
입력 `자재지역` 이 있으면 이름에 그 지역이 든 줄만(그런 줄이 없으면 조건 안 전부).
|
||||
조건에 `검색어` 가 있으면 기본 검색어 찾기(`master_pick`)."""
|
||||
if cond.get("검색어"):
|
||||
return mp.search(master, cond, env, unit)
|
||||
want = [plain_spec(w) for w in str(cond.get("규격") or "").split()]
|
||||
want_name = [plain(w) for w in str(cond.get("이름") or "").split()]
|
||||
detail = cond.get("상세구분")
|
||||
@@ -160,6 +165,8 @@ def candidates(
|
||||
|
||||
def pick(master: mf.Master, cond: dict, env: dict, unit: str | None = None) -> str:
|
||||
"""시험 계산이 쓸 줄 — 관리자가 정한 `대표`, 없으면 조건 안 값 있는 첫 줄(단위 같은 줄만)."""
|
||||
if cond.get("검색어"):
|
||||
return mp.pick(master, cond, env, unit)
|
||||
if cond.get("대표"):
|
||||
return str(cond["대표"])
|
||||
keys = candidates(master, cond, env, unit)
|
||||
@@ -173,6 +180,8 @@ def pick(master: mf.Master, cond: dict, env: dict, unit: str | None = None) -> s
|
||||
def check_unit(master: mf.Master, where: str, cond: dict, unit: str | None) -> list[str]:
|
||||
"""단위 경고 — 호표 줄·품셈재료 줄 단위와 맞는 후보가 없거나 대표 줄 단위가 다름.
|
||||
틀린 데이터가 아니라 좁혀야 할 조건이라 `check_pick` 과 따로 봄(`check_master 단위`)."""
|
||||
if cond.get("검색어"):
|
||||
return mp.check_warn(master, where, cond, unit)
|
||||
cond = static(cond)
|
||||
rows = master.index.get(MARKET, {})
|
||||
rep = str(cond.get("대표") or "")
|
||||
@@ -194,6 +203,8 @@ def check_pick(master: mf.Master, where: str, cond: dict, unit: str | None = Non
|
||||
값에 `{입력}` 이 든 칸(관경 등)은 계산 때 채워지므로 검사에서 뺌.
|
||||
지역·계약종별 조건은 구분 없이 이름 하나로 자재품목·유가전력을 넓게 찾음(_region · _tariff)
|
||||
— 여기서는 이름 칸만 있는지 봄(후보 0 은 계산 때 판단)."""
|
||||
if cond.get("검색어") is not None and not set(cond) - {*PICK_KEYS, "검색어"}:
|
||||
return mp.check_zero(master, where, cond)
|
||||
if set(cond) - set(PICK_KEYS):
|
||||
return [f"{where} · 재료 고르기 조건 모양 「{cond}」 — {' · '.join(PICK_KEYS)}"]
|
||||
if ("지역" in cond and cond["지역"] != "입력") or (
|
||||
@@ -257,3 +268,4 @@ def element(
|
||||
|
||||
|
||||
import master_formula as mf # noqa: E402 — 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
|
||||
import master_pick as mp # noqa: E402 — 검색어 찾기
|
||||
|
||||
@@ -0,0 +1,161 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""재료 줄의 기본 검색어 찾기 · 고른 품목 · 단위 환산 · 단위 경고 (PLAN 8-1 계약).
|
||||
|
||||
`master_formula.run` 이 재료 줄 단가를 풀 때 부름 — 요소 객체에 `검색어` 가 있으면 여기서 찾고,
|
||||
없으면 옛 길(`master_material` 조건 · 대표). 서로 부르는 모듈이라 `master_formula` 는 끝에서 읽음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from contextlib import contextmanager
|
||||
from contextvars import ContextVar
|
||||
from decimal import Decimal
|
||||
|
||||
import master_material as mm
|
||||
|
||||
# 「같은 성격」 단위 — {성격: {정규 단위: 기준 단위 몇 배}} (키는 `plain_unit` 을 거친 꼴)
|
||||
UNITS = {
|
||||
"무게": {"g": 1, "kg": 1000, "톤": 1000000},
|
||||
"길이": {"mm": 1, "cm": 10, "m": 1000, "km": 1000000},
|
||||
"넓이": {"cm2": 1, "m2": 10000},
|
||||
"부피": {"cm3": 1, "ℓ": 1000, "m3": 1000000},
|
||||
}
|
||||
_SCALE = {u: (kind, n) for kind, group in UNITS.items() for u, n in group.items()}
|
||||
REGIONS = (
|
||||
"전국평균 전국 서울 경기 강원 충북 충남 전북 전남 경북 경남 부산 대구 인천 대전 울산 세종 제주 광주"
|
||||
" 전남광주"
|
||||
).split()
|
||||
|
||||
CHOSEN: ContextVar[dict | None] = ContextVar("고름", default=None) # {호표 줄 차례(0부터): 자재 키}
|
||||
EQ: ContextVar[dict | None] = ContextVar("기계번호", default=None) # 기계 마스터 {원문번호: 줄}
|
||||
|
||||
|
||||
@contextmanager
|
||||
def choosing(picks: dict | None):
|
||||
"""`/calc` · `/text` 몸의 `고름` — 그 요청 동안만 · 저장 안 함."""
|
||||
token = CHOSEN.set({str(k): str(v) for k, v in (picks or {}).items()})
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
CHOSEN.reset(token)
|
||||
|
||||
|
||||
def machine(spec: dict, value) -> bool:
|
||||
"""기계 입력 — 고르기 목록 밖 원문 분류번호도 기계 마스터에 있으면 받음."""
|
||||
known = EQ.get() or {}
|
||||
picks = spec.get("고르기") or []
|
||||
return bool(picks) and str(value).strip() in known and all(str(o) in known for o in picks)
|
||||
|
||||
|
||||
# ── 단위 ───────────────────────────────────────────────────────────────
|
||||
def kind_of(unit) -> str | None:
|
||||
got = _SCALE.get(mm.plain_unit(unit))
|
||||
return got[0] if got else None
|
||||
|
||||
|
||||
def same_kind(a, b) -> bool:
|
||||
"""단위가 같거나 같은 성격(무게 · 길이 · 넓이 · 부피)."""
|
||||
pa, pb = mm.plain_unit(a), mm.plain_unit(b)
|
||||
return pa == pb or (kind_of(a) is not None and kind_of(a) == kind_of(b))
|
||||
|
||||
|
||||
def convert(price, have, want):
|
||||
"""`have` 단위 단가 → `want` 단위 단가 — 같은 성격이 아니면 그대로."""
|
||||
if price is None or not want or mm.plain_unit(have) == mm.plain_unit(want):
|
||||
return price
|
||||
if not same_kind(have, want) or kind_of(have) is None:
|
||||
return price
|
||||
return price * Decimal(_SCALE[mm.plain_unit(want)][1]) / Decimal(_SCALE[mm.plain_unit(have)][1])
|
||||
|
||||
|
||||
# ── 찾기 ───────────────────────────────────────────────────────────────
|
||||
def _words(term) -> tuple[list[str], list[str]]:
|
||||
"""(이름·규격에 든 낱말, 지역 낱말) — 지역 낱말은 고르는 차례에만 쓰임."""
|
||||
every = [mm.plain_spec(w) for w in str(term or "").split()]
|
||||
region = [w for w in every if w in REGIONS]
|
||||
return [w for w in every if w not in REGIONS], region
|
||||
|
||||
|
||||
def search(master, cond: dict, env: dict | None = None, unit: str | None = None) -> list[str]:
|
||||
"""검색어 안 자재품목 키 — 낱말이 모두 이름 또는 규격에 든 줄(요소의 구분 · 상세구분 안에서) ·
|
||||
단위는 같은 성격까지(하나도 없으면 다 — 경고가 붙음) · 고르는 차례:
|
||||
값 있는 줄 → 줄 단위와 똑같은 단위 → 지역 낱말(입력 `자재지역` 포함)과 맞는 줄 → 키 차례."""
|
||||
words, region = _words(cond.get("검색어"))
|
||||
region += [mm.plain(env[mm.REGION])] if (env or {}).get(mm.REGION) else []
|
||||
rows = master.index.get(mm.MARKET, {})
|
||||
hits = [
|
||||
key
|
||||
for _, name, spec, _, key in mm._market_index(master)
|
||||
if all(w in name.replace("×", "x") or w in spec for w in words)
|
||||
and (not cond.get("구분") or rows[key].get("구분") == cond["구분"])
|
||||
and (not cond.get("상세구분") or rows[key].get("상세구분") == cond["상세구분"])
|
||||
]
|
||||
if unit:
|
||||
kin = [k for k in hits if same_kind(rows[k].get("단위"), unit)]
|
||||
hits = kin or hits
|
||||
want = mm.plain_unit(unit) if unit else None
|
||||
|
||||
def rank(key):
|
||||
one = rows[key]
|
||||
name = mm.plain(one.get("이름"))
|
||||
return (
|
||||
not mm._offers(master, key),
|
||||
bool(want) and mm.plain_unit(one.get("단위")) != want,
|
||||
not (region and all(r in name for r in region)),
|
||||
)
|
||||
|
||||
return sorted(hits, key=rank) # 정렬은 안정 — 남는 차례는 파일 차례
|
||||
|
||||
|
||||
def pick(master, cond: dict, env: dict, unit: str | None = None) -> str:
|
||||
keys = search(master, cond, env, unit)
|
||||
if not keys:
|
||||
raise mm.mf.FormulaError(f"재료 검색어 후보 없음 — {cond.get('검색어')}")
|
||||
return keys[0]
|
||||
|
||||
|
||||
def priced(master, item: dict, ref, env: dict, index: int | None):
|
||||
"""재료 줄 단가 — (단가, 출처, 까닭, 단위경고). 고른 품목(`고름`)이 있으면 그것 · 검색어가 있으면 찾기 ·
|
||||
없으면 옛 길. 자재 단가는 줄 단위로 환산 · 성격이 다르면 그대로 두고 경고."""
|
||||
unit = item.get("단위")
|
||||
picked = (CHOSEN.get() or {}).get(str(index)) if index is not None else None
|
||||
try:
|
||||
if picked or (isinstance(ref, dict) and ref.get("검색어")):
|
||||
ref = picked or pick(master, ref, env, unit)
|
||||
have = master.get(ref).get("단위") if ref[:2] == mm.MARKET else None
|
||||
price, source = mm.element(master, ref, env, None)
|
||||
warn = None
|
||||
if have and unit and not same_kind(have, unit):
|
||||
warn = f"줄 {unit} · 자재 {have}"
|
||||
price = convert(price, have, unit) if have and unit else price
|
||||
else:
|
||||
price, source = mm.element(master, ref, env, unit)
|
||||
warn = None
|
||||
except mm.mf.FormulaError as e:
|
||||
return None, None, str(e), None
|
||||
why = None if price is not None else f"「{master.label(ref)}」 값 없음 — 관리자가 채울 값"
|
||||
return price, source, why, warn
|
||||
|
||||
|
||||
# ── 검사 ───────────────────────────────────────────────────────────────
|
||||
def check_zero(master, where: str, cond: dict) -> list[str]:
|
||||
"""검색어 후보 0 — `{입력}` 이 든 검색어는 계산 때 채워져 여기서 못 봄."""
|
||||
term = str(cond.get("검색어") or "")
|
||||
if not term.strip() or "{" in term or any("{" in str(v) for v in cond.values()):
|
||||
return [] if term.strip() else [f"{where} · 검색어 비어 있음"]
|
||||
return [] if search(master, cond) else [f"{where} · 검색어 「{term}」 후보 0"]
|
||||
|
||||
|
||||
def check_warn(master, where: str, cond: dict, unit: str | None) -> list[str]:
|
||||
"""단위 경고 줄 — 검색어 후보가 있으나 줄 단위와 같은 성격이 하나도 없음."""
|
||||
term = str(cond.get("검색어") or "")
|
||||
if not unit or "{" in term or "{" in str(cond.get("구분") or ""):
|
||||
return []
|
||||
keys = search(master, cond)
|
||||
rows = master.index.get(mm.MARKET, {})
|
||||
if keys and not any(same_kind(rows[k].get("단위"), unit) for k in keys):
|
||||
return [f"{where} · 검색어 「{term}」 후보 단위가 줄 단위 「{unit}」 과 성격이 다름"]
|
||||
return []
|
||||
|
||||
|
||||
import master_formula as mf # noqa: E402, F401 — 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
|
||||
Reference in New Issue
Block a user