tr-imar 0.1.0__py3-none-any.whl

tr_imar/__init__.py

@@ -0,0 +1,118 @@
+"""tr_imar: Planlı Alanlar İmar Yönetmeliği ve Otopark Yönetmeliği hesapları.
+
+Turkish zoning (imar) calculations: TAKS/KAKS, emsal dışı areas and the 30 %
+cap, floor count / building height, setbacks, buildable envelope of a parcel,
+parking requirement and a compliance check with Turkish messages.
+
+Hızlı başlangıç::
+
+    from tr_imar import PlanConditions, Project, check_compliance
+
+    plan = PlanConditions(taks=0.35, kaks=1.40, floors=4, nizam="ayrik")
+    proje = Project(parcel_area=1000, footprint=340, floor_area=1360, floors=4,
+                    building_height=14.4, setbacks={"on": 5, "yan": 3, "arka": 3})
+    print(check_compliance(proje, plan).to_text())
+"""
+
+from ._version import __version__
+from .compliance import CheckItem, ComplianceReport, Project, check_compliance
+from .config import FIELD_SOURCES, NATIONAL, FieldSource, ImarConfig, load_config
+from .density import DensityResult, resolve_density
+from .emsal import (
+    EMSAL_DISI_CATEGORIES,
+    EmsalDisiItem,
+    EmsalDisiLine,
+    EmsalDisiResult,
+    evaluate_emsal_disi,
+)
+from .errors import ImarConfigError, ImarError, ImarGeometryError, ImarInputError
+from .geometry import (
+    Envelope,
+    RectangleEnvelope,
+    buildable_envelope,
+    classify_edges,
+    is_convex,
+    offset_polygon,
+    polygon_area,
+    rectangle_envelope,
+)
+from .height import (
+    classify_height,
+    floor_height_limits,
+    floors_by_road_width,
+    floors_for_setbacks,
+    max_building_height,
+)
+from .parking import (
+    DEFAULT_PARKING_TABLE,
+    ParkingDemand,
+    ParkingLine,
+    ParkingResult,
+    ParkingRule,
+    ParkingTable,
+    parking_requirement,
+)
+from .plan import NIZAM_TYPES, ZONE_TYPES, PlanConditions
+from .setbacks import SetbackRequirement, required_setbacks, tower_spacing
+
+# Türkçe takma adlar (isteğe bağlı)
+uygunluk_kontrolu = check_compliance
+bahce_mesafeleri = required_setbacks
+yapilasma_zarfi = buildable_envelope
+otopark_ihtiyaci = parking_requirement
+yogunluk = resolve_density
+
+__all__ = [
+    "DEFAULT_PARKING_TABLE",
+    "EMSAL_DISI_CATEGORIES",
+    "FIELD_SOURCES",
+    "NATIONAL",
+    "NIZAM_TYPES",
+    "ZONE_TYPES",
+    "CheckItem",
+    "ComplianceReport",
+    "DensityResult",
+    "EmsalDisiItem",
+    "EmsalDisiLine",
+    "EmsalDisiResult",
+    "Envelope",
+    "FieldSource",
+    "ImarConfig",
+    "ImarConfigError",
+    "ImarError",
+    "ImarGeometryError",
+    "ImarInputError",
+    "ParkingDemand",
+    "ParkingLine",
+    "ParkingResult",
+    "ParkingRule",
+    "ParkingTable",
+    "PlanConditions",
+    "Project",
+    "RectangleEnvelope",
+    "SetbackRequirement",
+    "__version__",
+    "bahce_mesafeleri",
+    "buildable_envelope",
+    "check_compliance",
+    "classify_edges",
+    "classify_height",
+    "evaluate_emsal_disi",
+    "floor_height_limits",
+    "floors_by_road_width",
+    "floors_for_setbacks",
+    "is_convex",
+    "load_config",
+    "max_building_height",
+    "offset_polygon",
+    "otopark_ihtiyaci",
+    "parking_requirement",
+    "polygon_area",
+    "rectangle_envelope",
+    "required_setbacks",
+    "resolve_density",
+    "tower_spacing",
+    "uygunluk_kontrolu",
+    "yapilasma_zarfi",
+    "yogunluk",
+]

tr_imar/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

tr_imar/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

tr_imar/cli.py

@@ -0,0 +1,537 @@
+"""Komut satırı arayüzü: ``tr-imar``.
+
+Alt komutlar: ``yogunluk``, ``cekme``, ``yukseklik``, ``zarf``, ``otopark``,
+``kontrol``, ``yapilandirma``. Ayrıntı için ``tr-imar <komut> --help``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, TextIO
+
+from ._version import __version__
+from .compliance import Project, check_compliance
+from .config import FIELD_SOURCES, NATIONAL, ImarConfig, load_config
+from .density import resolve_density
+from .errors import ImarError
+from .geometry import buildable_envelope, polygon_area, rectangle_envelope
+from .height import (
+    classify_height,
+    floor_height_limits,
+    floors_by_road_width,
+    max_building_height,
+)
+from .parking import DEFAULT_PARKING_TABLE, ParkingDemand, ParkingTable, parking_requirement
+from .plan import NIZAM_TYPES, ZONE_TYPES, PlanConditions
+from .setbacks import required_setbacks
+
+__all__ = ["build_parser", "main"]
+
+
+def _num(x: Optional[float], unit: str = "", nd: int = 2) -> str:
+    if x is None:
+        return "-"
+    s = f"{x:,.{nd}f}".replace(",", "X").replace(".", ",").replace("X", ".")
+    return f"{s} {unit}".rstrip()
+
+
+def _dump(obj: Any, out: TextIO) -> None:
+    out.write(json.dumps(obj, ensure_ascii=False, indent=2, default=str) + "\n")
+
+
+def _config(args: argparse.Namespace) -> ImarConfig:
+    return load_config(args.config) if getattr(args, "config", None) else NATIONAL
+
+
+def _plan_from_args(args: argparse.Namespace) -> PlanConditions:
+    return PlanConditions(
+        taks=getattr(args, "taks", None),
+        kaks=getattr(args, "kaks", None),
+        floors=getattr(args, "kat", None),
+        nizam=getattr(args, "nizam", "ayrik") or "ayrik",
+        front_setback=getattr(args, "plan_on", None),
+        side_setback=getattr(args, "plan_yan", None),
+        rear_setback=getattr(args, "plan_arka", None),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Komutlar
+# ---------------------------------------------------------------------------
+
+
+def _cmd_yogunluk(args: argparse.Namespace, out: TextIO) -> int:
+    cfg = _config(args)
+    plan = _plan_from_args(args)
+    res = resolve_density(args.parsel, plan, envelope_area=args.zarf_alani, config=cfg)
+    if args.json:
+        _dump(res.to_dict(), out)
+        return 0
+    out.write(f"Net parsel alanı        : {_num(res.parcel_area, 'm²')}\n")
+    out.write(
+        f"Azami taban alanı       : {_num(res.max_footprint, 'm²')}  (TAKS {res.taks:.4f}; "
+        f"{res.sources.get('taks', '')})\n"
+    )
+    out.write(
+        f"Azami emsal alanı       : {_num(res.max_floor_area, 'm²')}"
+        + (f"  (KAKS {res.kaks:.4f}; {res.sources.get('kaks', '')})" if res.kaks else "")
+        + "\n"
+    )
+    out.write(f"Emsal dışı %30 tavanı   : {_num(res.emsal_disi_cap, 'm²')}  (PAİY m.5/8)\n")
+    for n in res.notes:
+        out.write(f"  * {n}\n")
+    return 0
+
+
+def _cmd_cekme(args: argparse.Namespace, out: TextIO) -> int:
+    cfg = _config(args)
+    if args.kat is None and args.yukseklik is None:
+        raise ImarError("--kat veya --yukseklik verilmeli")
+    plan = PlanConditions(
+        nizam=args.nizam,
+        front_setback=args.plan_on,
+        side_setback=args.plan_yan,
+        rear_setback=args.plan_arka,
+    )
+    req = required_setbacks(
+        floors=args.kat,
+        height=args.yukseklik,
+        plan=plan,
+        floor_height=args.kat_yuksekligi,
+        config=cfg,
+    )
+    if args.json:
+        _dump(req.to_dict(), out)
+        return 0
+    out.write(f"Hesaba esas kat adedi : {req.floors_counted}\n")
+    out.write(f"Ön bahçe              : {_num(req.front, 'm')}  ({req.sources['front']})\n")
+    yan = "aranmaz (bitişik)" if req.attached_sides >= 2 else _num(req.side, "m")
+    out.write(f"Yan bahçe             : {yan}  ({req.sources['side']})\n")
+    out.write(f"Arka bahçe            : {_num(req.rear, 'm')}  ({req.sources['rear']})\n")
+    if req.side != req.side_park:
+        out.write(
+            f"Park alanına komşu yan/arka: {_num(req.side_park, 'm')} / "
+            f"{_num(req.rear_park, 'm')}\n"
+        )
+    for n in req.notes:
+        out.write(f"  * {n}\n")
+    return 0
+
+
+def _cmd_yukseklik(args: argparse.Namespace, out: TextIO) -> int:
+    cfg = _config(args)
+    result: Dict[str, Any] = {}
+    if args.yol is not None:
+        result["yol_genisligi"] = args.yol
+        result["en_cok_kat"] = floors_by_road_width(args.yol, cfg)
+    floors = args.kat if args.kat is not None else result.get("en_cok_kat")
+    if floors is not None:
+        lim = floor_height_limits(
+            args.bolge, floors=floors, ground_mezzanine=args.asma_kat, config=cfg
+        )
+        result["kat"] = floors
+        result["kat_yukseklikleri"] = lim
+        result["hmax"] = max_building_height(
+            floors, args.bolge, ground_mezzanine=args.asma_kat, config=cfg
+        )
+        result["hmax_subasman_dahil"] = max_building_height(
+            floors,
+            args.bolge,
+            ground_mezzanine=args.asma_kat,
+            include_subasman=True,
+            subasman=args.subasman,
+            config=cfg,
+        )
+    if args.siniflandir is not None:
+        result["sinif"] = classify_height(args.siniflandir, args.yapi_yuksekligi, cfg)
+    if not result:
+        raise ImarError("--kat, --yol veya --siniflandir verilmeli")
+    if args.json:
+        _dump(result, out)
+        return 0
+    if "en_cok_kat" in result:
+        out.write(
+            f"Yol genişliği {_num(args.yol, 'm')} -> en çok {result['en_cok_kat']} kat "
+            "(bodrum hariç; PAİY m.9/1-a)\n"
+        )
+    if "hmax" in result:
+        lim = result["kat_yukseklikleri"]
+        out.write(
+            f"Bölge: {args.bolge}, {result['kat']} kat; azami kat yüksekliği zemin "
+            f"{_num(lim['zemin'], 'm')}, normal {_num(lim['normal'], 'm')} (PAİY m.28/1)\n"
+        )
+        out.write(f"Hmax = {_num(result['hmax'], 'm')} (PAİY m.28/2)\n")
+        out.write(f"Hmax (subasman dahil, m.9/1-c) = {_num(result['hmax_subasman_dahil'], 'm')}\n")
+    if "sinif" in result:
+        ad = {
+            "normal": "yüksek yapı değil",
+            "yuksek": "yüksek yapı",
+            "cok_yuksek": "çok yüksek yapı",
+        }[result["sinif"]]
+        out.write(f"Yükseklik sınıfı: {ad} (PAİY m.4/1-aaaaa)\n")
+    return 0
+
+
+def _parse_polygon(text: str) -> List[List[float]]:
+    pts: List[List[float]] = []
+    for part in text.replace("\n", ";").split(";"):
+        part = part.strip()
+        if not part:
+            continue
+        xy = [float(v) for v in part.replace(" ", ",").split(",") if v]
+        if len(xy) != 2:
+            raise ImarError(f"Koordinat 'x,y' biçiminde olmalı: {part!r}")
+        pts.append(xy)
+    return pts
+
+
+def _read_geojson_polygon(path: str) -> List[List[float]]:
+    data = json.loads(Path(path).read_text(encoding="utf-8"))
+    if data.get("type") == "FeatureCollection":
+        if not data.get("features"):
+            raise ImarError("GeoJSON içinde detay (feature) yok")
+        data = data["features"][0]
+    geom = data.get("geometry", data)
+    if geom.get("type") == "Polygon":
+        return [list(map(float, c[:2])) for c in geom["coordinates"][0]]
+    if geom.get("type") == "MultiPolygon" and len(geom["coordinates"]) == 1:
+        return [list(map(float, c[:2])) for c in geom["coordinates"][0][0]]
+    raise ImarError("GeoJSON geometrisi tek parçalı Polygon olmalı")
+
+
+def _cmd_zarf(args: argparse.Namespace, out: TextIO) -> int:
+    cfg = _config(args)
+    if args.kat is None and args.yukseklik is None:
+        raise ImarError("--kat veya --yukseklik verilmeli")
+    plan = PlanConditions(
+        nizam=args.nizam,
+        front_setback=args.plan_on,
+        side_setback=args.plan_yan,
+        rear_setback=args.plan_arka,
+    )
+    req = required_setbacks(floors=args.kat, height=args.yukseklik, plan=plan, config=cfg)
+    if args.dikdortgen:
+        try:
+            w, d = (float(v) for v in args.dikdortgen.lower().split("x"))
+        except ValueError as exc:
+            raise ImarError("--dikdortgen CEPHExDERINLIK biçiminde olmalı, ör. 20x30") from exc
+        att = req.attached_sides
+        env = rectangle_envelope(
+            w,
+            d,
+            req.front,
+            0.0 if att >= 1 else req.side,
+            req.rear,
+            side2=0.0 if att >= 2 else req.side,
+        )
+        res = {
+            "parsel_alani": w * d,
+            "zarf_genislik": env.width,
+            "zarf_derinlik": env.depth,
+            "zarf_alani": env.area,
+            "on": req.front,
+            "yan": req.side,
+            "arka": req.rear,
+        }
+        if args.json:
+            _dump(res, out)
+        else:
+            out.write(f"Parsel {_num(w, 'm')} x {_num(d, 'm')} = {_num(w * d, 'm²')}\n")
+            out.write(
+                f"Çekmeler: ön {_num(req.front, 'm')}, yan {_num(req.side, 'm')}"
+                f"{' (bitişik cephe 0)' if att else ''}, arka {_num(req.rear, 'm')}\n"
+            )
+            out.write(
+                f"Zarf {_num(env.width, 'm')} x {_num(env.depth, 'm')} = {_num(env.area, 'm²')}\n"
+            )
+        return 0
+    if args.poligon:
+        coords = _parse_polygon(args.poligon)
+    elif args.geojson:
+        coords = _read_geojson_polygon(args.geojson)
+    else:
+        raise ImarError("--dikdortgen, --poligon veya --geojson verilmeli")
+    roles = [r.strip() for r in args.roller.split(",")] if args.roller else None
+    if roles is None and not args.on_kenar:
+        raise ImarError("Poligon için --on-kenar veya --roller verilmeli")
+    env_p = buildable_envelope(
+        coords, req, edge_roles=roles, front_edges=args.on_kenar or None, method=args.yontem
+    )
+    if args.cikti:
+        Path(args.cikti).write_text(
+            json.dumps(env_p.to_geojson(), ensure_ascii=False, indent=2), encoding="utf-8"
+        )
+    if args.json:
+        _dump(env_p.to_geojson(), out)
+        return 0
+    out.write(f"Parsel alanı : {_num(polygon_area(coords), 'm²')}\n")
+    for i, (r, dist) in enumerate(zip(env_p.edge_roles, env_p.edge_distances)):
+        out.write(f"  kenar {i}: {r:<9} {_num(dist, 'm')}\n")
+    out.write(
+        f"Zarf alanı   : {_num(env_p.area, 'm²')} ({env_p.method}, {len(env_p.parts)} parça)\n"
+    )
+    for part in env_p.parts:
+        out.write("  " + "; ".join(f"{x:.3f},{y:.3f}" for x, y in part) + "\n")
+    for n in env_p.notes:
+        out.write(f"  * {n}\n")
+    if args.cikti:
+        out.write(f"GeoJSON yazıldı: {args.cikti}\n")
+    return 0
+
+
+def _parking_table(args: argparse.Namespace) -> ParkingTable:
+    if getattr(args, "tablo", None):
+        return ParkingTable.from_json(args.tablo)
+    return DEFAULT_PARKING_TABLE
+
+
+def _cmd_otopark(args: argparse.Namespace, out: TextIO) -> int:
+    table = _parking_table(args)
+    if args.liste:
+        if args.json:
+            _dump(table.to_dict(), out)
+            return 0
+        group = None
+        for key, rule in table.items():
+            if rule.group != group:
+                group = rule.group
+                out.write(f"{group}\n")
+            if rule.kind == "mesken":
+                desc = rule.note
+            elif rule.kind == "oran":
+                desc = f"{rule.unit} x {rule.per:g}"
+            elif rule.kind in ("adet",):
+                desc = f"{rule.per:g} {rule.unit} için 1"
+            elif rule.kind == "akaryakit":
+                desc = "pompa ve lift/kanal başına 1"
+            else:
+                desc = f"{rule.per:g} m² için 1"
+                if rule.min_one_per_unit:
+                    desc += " (bağımsız bölüm başına en az 1)"
+            out.write(f"  {key:<18} {rule.label}: {desc}\n")
+        out.write(f"Kaynak: {table.source}\n")
+        return 0
+    demands: List[ParkingDemand] = []
+    if args.girdi:
+        data = json.loads(Path(args.girdi).read_text(encoding="utf-8"))
+        if isinstance(data, dict):
+            data = data.get("otopark", data.get("parking", [data]))
+        demands.extend(ParkingDemand.from_dict(d) for d in data)
+    daireler: List[float] = []
+    for d in args.daire or []:
+        daireler.extend(float(v) for v in str(d).split(",") if v.strip())
+    if daireler:
+        demands.append(ParkingDemand("mesken", unit_areas=daireler))
+    for spec in args.kullanim or []:
+        if "=" not in spec:
+            raise ImarError(f"--kullanim ANAHTAR=MİKTAR biçiminde olmalı: {spec!r}")
+        key, val = spec.split("=", 1)
+        rule = table[key.strip()]
+        q = float(val)
+        if rule.kind in ("adet", "oran"):
+            demands.append(ParkingDemand(rule.key, count=q))
+        elif rule.kind == "akaryakit":
+            demands.append(ParkingDemand(rule.key, pumps=int(q)))
+        else:
+            demands.append(ParkingDemand(rule.key, area=q))
+    if not demands:
+        raise ImarError("En az bir kullanım verilmeli (--daire, --kullanim veya --girdi)")
+    res = parking_requirement(
+        demands, table=table, factor=args.katsayi, residential_reduction=args.azaltma
+    )
+    if args.json:
+        _dump(res.to_dict(), out)
+        return 0
+    for line in res.lines:
+        out.write(f"{line.label}: {line.basis} -> {line.spaces:.2f}\n")
+    out.write(f"Toplam (ham) : {res.raw_total:.2f}\n")
+    out.write(f"Zorunlu otopark: {res.total} adet\n")
+    for k, v in res.extras.items():
+        out.write(f"Ayrıca: {v} adet {k.replace('_', ' ')} yeri\n")
+    for n in res.notes:
+        out.write(f"  * {n}\n")
+    return 0
+
+
+def _cmd_kontrol(args: argparse.Namespace, out: TextIO) -> int:
+    cfg = _config(args)
+    try:
+        data = json.loads(Path(args.proje).read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise ImarError(f"Proje dosyası okunamadı: {args.proje} ({exc})") from exc
+    if not isinstance(data, dict):
+        raise ImarError("Proje dosyası bir JSON nesnesi olmalı")
+    plan = PlanConditions.from_dict(data.get("plan", {}))
+    proje_data = data.get("proje", data.get("project")) or {}
+    proje = Project.from_dict(proje_data)
+    if "yapilandirma" in data:
+        cfg = ImarConfig.from_dict(data["yapilandirma"], base=cfg)
+    table = _parking_table(args)
+    if "otopark_tablosu" in data:
+        table = table.with_overrides(data["otopark_tablosu"])
+    report = check_compliance(proje, plan, cfg, parking_table=table, envelope_method=args.yontem)
+    if args.json:
+        out.write(report.to_json() + "\n")
+    else:
+        out.write(report.to_text() + "\n")
+    return 0 if report.ok else 1
+
+
+def _cmd_yapilandirma(args: argparse.Namespace, out: TextIO) -> int:
+    cfg = _config(args)
+    if args.kaynaklar:
+        rows = {
+            name: {
+                "deger": cfg.to_dict()[name],
+                "dayanak": fs.article,
+                "degistirilemez": fs.protected,
+                "aciklama": fs.description,
+            }
+            for name, fs in FIELD_SOURCES.items()
+        }
+        _dump(rows, out)
+    else:
+        _dump(cfg.to_dict(), out)
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# Ayrıştırıcı
+# ---------------------------------------------------------------------------
+
+
+def build_parser() -> argparse.ArgumentParser:
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument(
+        "--config",
+        "--yapilandirma",
+        dest="config",
+        metavar="JSON",
+        help="Ulusal varsayılanları değiştiren yerel yönetmelik JSON dosyası",
+    )
+    common.add_argument("--json", action="store_true", help="Çıktıyı JSON olarak yaz")
+
+    p = argparse.ArgumentParser(
+        prog="tr-imar",
+        description="Planlı Alanlar İmar Yönetmeliği ve Otopark Yönetmeliği hesapları "
+        "(TAKS/KAKS, emsal dışı, bahçe mesafeleri, yapılaşma zarfı, otopark, uyum kontrolü).",
+        epilog="Sonuçlar ön kontrol niteliğindedir; plan notları ve idarenin yorumu esastır.",
+    )
+    p.add_argument("--version", "--surum", action="version", version=f"tr-imar {__version__}")
+    sub = p.add_subparsers(dest="komut", metavar="KOMUT")
+
+    s = sub.add_parser("yogunluk", parents=[common], help="Taban alanı, emsal alanı, %%30 tavanı")
+    s.add_argument("--parsel", type=float, required=True, help="Net imar parseli alanı (m²)")
+    s.add_argument("--taks", type=float, help="Plandaki TAKS")
+    s.add_argument("--kaks", "--emsal", dest="kaks", type=float, help="Plandaki KAKS (emsal)")
+    s.add_argument("--kat", type=int, help="Kat adedi (bodrum hariç)")
+    s.add_argument("--nizam", choices=NIZAM_TYPES, default="ayrik", help="Yapı nizamı")
+    s.add_argument("--zarf-alani", type=float, help="Çekmeler sonrası zarf alanı (m²)")
+    s.set_defaults(func=_cmd_yogunluk)
+
+    s = sub.add_parser("cekme", parents=[common], help="Asgari ön/yan/arka bahçe mesafeleri")
+    s.add_argument("--kat", type=int, help="Zemin üstü bodrumlar dahil kat adedi")
+    s.add_argument("--yukseklik", type=float, help="Görünen bina yüksekliği (m)")
+    s.add_argument("--nizam", choices=NIZAM_TYPES, default="ayrik")
+    s.add_argument("--plan-on", type=float, help="Plan notundaki ön bahçe (m)")
+    s.add_argument("--plan-yan", type=float, help="Plan notundaki yan bahçe (m)")
+    s.add_argument("--plan-arka", type=float, help="Plan notundaki arka bahçe (m)")
+    s.add_argument("--kat-yuksekligi", type=float, help="60.50 m üstü için tipik kat yüksekliği")
+    s.set_defaults(func=_cmd_cekme)
+
+    s = sub.add_parser("yukseklik", parents=[common], help="Hmax, yol genişliğine göre kat, sınıf")
+    s.add_argument("--kat", type=int, help="Kat adedi (bodrum hariç)")
+    s.add_argument("--bolge", choices=ZONE_TYPES, default="konut", help="Kat yüksekliği bölgesi")
+    s.add_argument("--asma-kat", action="store_true", help="Asma katlı zemin kat")
+    s.add_argument("--subasman", type=float, help="Subasman yüksekliği (m, en çok 1.20)")
+    s.add_argument("--yol", type=float, help="Ön cephedeki yolun plan genişliği (m)")
+    s.add_argument(
+        "--siniflandir",
+        type=float,
+        metavar="BINA_H",
+        help="Bina yüksekliğine göre yüksek yapı sınıfı",
+    )
+    s.add_argument("--yapi-yuksekligi", type=float, help="Yapı yüksekliği (m)")
+    s.set_defaults(func=_cmd_yukseklik)
+
+    s = sub.add_parser("zarf", parents=[common], help="Parselde yapılaşma zarfı")
+    g = s.add_mutually_exclusive_group()
+    g.add_argument("--dikdortgen", metavar="CEPHExDERINLIK", help="Dikdörtgen parsel, ör. 20x30")
+    g.add_argument("--poligon", metavar="'x,y;x,y;...'", help="Parsel köşeleri (metrik)")
+    g.add_argument("--geojson", metavar="DOSYA", help="Parsel poligonu (GeoJSON, metrik)")
+    s.add_argument(
+        "--on-kenar",
+        type=int,
+        action="append",
+        metavar="I",
+        help="Yola cepheli kenar indisi (tekrarlanabilir)",
+    )
+    s.add_argument("--roller", help="Kenar rolleri, ör. on,yan,arka,bitisik")
+    s.add_argument("--kat", type=int)
+    s.add_argument("--yukseklik", type=float)
+    s.add_argument("--nizam", choices=NIZAM_TYPES, default="ayrik")
+    s.add_argument("--plan-on", type=float)
+    s.add_argument("--plan-yan", type=float)
+    s.add_argument("--plan-arka", type=float)
+    s.add_argument(
+        "--yontem",
+        choices=("parallel", "exact"),
+        default="parallel",
+        help="parallel: paralel yaklaşma sınırları; exact: Öklid (shapely)",
+    )
+    s.add_argument("--cikti", metavar="DOSYA", help="Zarfı GeoJSON olarak yaz")
+    s.set_defaults(func=_cmd_zarf)
+
+    s = sub.add_parser("otopark", parents=[common], help="Otopark ihtiyacı (Ek-1)")
+    s.add_argument("--liste", action="store_true", help="Otopark tablosunu listele")
+    s.add_argument(
+        "--daire",
+        action="append",
+        metavar="M2[,M2...]",
+        help="Daire brüt alanları (tekrarlanabilir veya virgüllü)",
+    )
+    s.add_argument(
+        "--kullanim",
+        action="append",
+        metavar="ANAHTAR=MIKTAR",
+        help="ör. dukkan=240, otel_diger=60 (oda), spor_salonu=800 (oturma)",
+    )
+    s.add_argument("--girdi", metavar="JSON", help="Kullanım listesi JSON dosyası")
+    s.add_argument("--tablo", metavar="JSON", help="Tablo değişiklikleri JSON dosyası")
+    s.add_argument("--katsayi", type=float, default=1.0, help="Yerel artırma katsayısı")
+    s.add_argument(
+        "--azaltma", type=float, default=0.0, help="Küçük parsel konut azaltması (0-0.5)"
+    )
+    s.set_defaults(func=_cmd_otopark)
+
+    s = sub.add_parser("kontrol", parents=[common], help="Proje JSON dosyası için uyum raporu")
+    s.add_argument("proje", help="Proje JSON dosyası ({'plan': {...}, 'proje': {...}})")
+    s.add_argument("--tablo", metavar="JSON", help="Otopark tablosu değişiklikleri")
+    s.add_argument("--yontem", choices=("parallel", "exact"), default="parallel")
+    s.set_defaults(func=_cmd_kontrol)
+
+    s = sub.add_parser("yapilandirma", parents=[common], help="Eşik değerlerini JSON yaz")
+    s.add_argument("--kaynaklar", action="store_true", help="Dayanak maddeleriyle birlikte")
+    s.set_defaults(func=_cmd_yapilandirma)
+    return p
+
+
+def main(argv: Optional[Sequence[str]] = None, out: Optional[TextIO] = None) -> int:
+    """CLI giriş noktası. Dönüş: 0 başarılı/uygun, 1 aykırılık var, 2 hata."""
+    out = out if out is not None else sys.stdout
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if not getattr(args, "func", None):
+        parser.print_help(out)
+        return 2
+    try:
+        return int(args.func(args, out))
+    except ImarError as exc:
+        sys.stderr.write(f"tr-imar: hata: {exc}\n")
+        return 2
+    except (OSError, ValueError) as exc:
+        sys.stderr.write(f"tr-imar: hata: {exc}\n")
+        return 2