File size: 334,090 Bytes
bbf9732 d1292d8 bbf9732 4a105bf bbf9732 d1292d8 bbf9732 d1292d8 bbf9732 d1292d8 bbf9732 d1292d8 bbf9732 d1292d8 bbf9732 d1292d8 bbf9732 d1292d8 bbf9732 d1292d8 bbf9732 d1292d8 bbf9732 d1292d8 bbf9732 d1292d8 bbf9732 4a105bf bbf9732 4a105bf bbf9732 4a105bf bbf9732 4a105bf bbf9732 4a105bf bbf9732 4a105bf bbf9732 4a105bf bbf9732 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 | # BEGIN CHEM-180 ALICAT MC APPEND-ONLY RUNTIME
"""CHEM-180 simulator adapter; no hardware, robot, or real valve driver.
Only the trusted AlicatMCRuntime owns identity, gas compatibility evidence,
boundary conditions, and the common clock. Give an agent AlicatMCSession,
not the host. API filtering is not a Python/shared-filesystem sandbox.
"""
import copy as _amc_copy
import hashlib as _amc_hashlib
import json as _amc_json
import math as _amc_math
import threading as _amc_threading
ALICAT_MC_TYPE = "instrument.alicat_mc_1slpm_rev6"
ALICAT_MC_FS_M3_S = 1e-3 / 60
ALICAT_MC_MIN_M3_S = ALICAT_MC_FS_M3_S * 0.0001
ALICAT_MC_PSI_PA = 6894.757293168
ALICAT_MC_R = 8.31446261815324
# 2026-10 template hook: NIST gas-property library (scripts/basic40_templates/alicat_mc.py); host-registered gases keep the legacy path.
_AMC_TEMPLATE_CAPABILITIES = ("template.list", "template.read", "flow.read_template")
def _amc_templates():
try:
from basic40_templates import alicat_mc as module
except ImportError:
from scripts.basic40_templates import alicat_mc as module
return module
def _amc_template_backed(host, s, inst):
return inst is not None and ((s["gas.selected_id"] is not None and s["gas.selected_id"] not in host._gases) or inst.get("template_line_gas_id") is not None)
def _amc_number(value):
try:
return type(value) in (int, float) and _amc_math.isfinite(value)
except (TypeError, OverflowError):
return False
def _amc_finite_result(value):
return value if _amc_number(value) else None
def _amc_num(unit, minimum=None, maximum=None, nullable=False):
schema = {"type": "number", "x-unit": unit}
if minimum is not None:
schema["minimum"] = minimum
if maximum is not None:
schema["maximum"] = maximum
return {"anyOf": [schema, {"type": "null"}]} if nullable else schema
def _amc_obj(properties):
return {"type": "object", "properties": properties, "required": list(properties), "additionalProperties": False}
def _amc_slot(schema, unit, origin, visibility="agent", capability=None, parameter=None):
return {"value_schema": schema, "unit": unit, "origin": origin, "visibility": visibility,
"access": "read_write" if capability else "read_only",
"write_via": {"capability_id": capability, "parameter": parameter, "fixed_arguments": {}} if capability else None,
"reference_conditions": None, "sampling": {"mode": "instant", "time_domain": "simulation", "window": None}}
_AMC_NULL_STRING = {"anyOf": [{"type": "string"}, {"type": "null"}]}
_AMC_SLOTS = {
"power.enabled": _amc_slot({"type": "boolean"}, "1", "setpoint", capability="power.set", parameter="enabled"),
"gas.selected_id": _amc_slot(_AMC_NULL_STRING, "1", "setpoint", capability="gas.select", parameter="gas_id"),
"gas.reference_temperature_K": _amc_slot(_amc_num("K", 0), "K", "setpoint"),
"gas.reference_pressure_Pa": _amc_slot(_amc_num("Pa", 0), "Pa", "setpoint"),
"flow.setpoint_m3_s": _amc_slot(_amc_num("m^3/s", 0, ALICAT_MC_FS_M3_S), "m^3/s", "setpoint", capability="flow.set_setpoint", parameter="flow_rate_m3_s"),
"flow.zeroed": _amc_slot({"type": "boolean"}, "1", "derived"),
"ports.upstream_node_id": _amc_slot(_AMC_NULL_STRING, "1", "scene"),
"ports.downstream_node_id": _amc_slot(_AMC_NULL_STRING, "1", "scene"),
"simulation.dynamic_model_configured": _amc_slot({"type": "boolean"}, "1", "derived"),
"measurement.standard_flow_m3_s": _amc_slot(_amc_num("m^3/s", 0, nullable=True), "m^3/s", "derived"),
"measurement.actual_flow_m3_s": _amc_slot(_amc_num("m^3/s", 0, nullable=True), "m^3/s", "derived"),
"measurement.mass_flow_kg_s": _amc_slot(_amc_num("kg/s", 0, nullable=True), "kg/s", "derived"),
"measurement.pressure_Pa": _amc_slot(_amc_num("Pa", 0, nullable=True), "Pa", "derived"),
"measurement.temperature_K": _amc_slot(_amc_num("K", 0, nullable=True), "K", "derived"),
"measurement.total_standard_volume_m3": _amc_slot(_amc_num("m^3", 0, nullable=True), "m^3", "derived"),
"measurement.standard_accuracy_bound_m3_s": _amc_slot(_amc_num("m^3/s", 0, nullable=True), "m^3/s", "derived"),
"measurement.accuracy_conditions_met": _amc_slot({"type": "boolean"}, "1", "derived"),
"truth.standard_flow_m3_s": _amc_slot(_amc_num("m^3/s", 0, nullable=True), "m^3/s", "process_truth", "debug"),
"truth.total_standard_volume_m3": _amc_slot(_amc_num("m^3", 0, nullable=True), "m^3", "process_truth", "debug"),
"truth.upstream_pressure_Pa": _amc_slot(_amc_num("Pa", 0, nullable=True), "Pa", "process_truth", "debug"),
"truth.downstream_pressure_Pa": _amc_slot(_amc_num("Pa", 0, nullable=True), "Pa", "process_truth", "debug"),
"truth.temperature_K": _amc_slot(_amc_num("K", 0, nullable=True), "K", "process_truth", "debug"),
"truth.equilibrium": _amc_slot({"type": "boolean"}, "1", "process_truth", "debug"),
"truth.no_flow": _amc_slot({"type": "boolean"}, "1", "process_truth", "debug"),
"truth.response_time_constant_s": _amc_slot(_amc_num("s", 0, nullable=True), "s", "process_truth", "debug"),
}
_AMC_MEASUREMENTS = [key for key in _AMC_SLOTS if key.startswith("measurement.")]
_AMC_LIMITATIONS = [
"仅为合成过程与接口实现，无硬件驱动、机器人或真实阀动作。",
"气体兼容性由可信宿主登记；厂家98种气体和20个混气定义的数据库未实现。未知摩尔质量及性质保持null。",
"动态没有缺省时间常数。宿主必须给出明确假设及证据；最快T63 30 ms不是稳定时间，也不自动作为tau。",
"简化一阶模型仅在有效供压/背压和温度条件下使用。阀特性、压降曲线、PID、真实稳定判据和非理想气体性质未实现。",
"模型读数均为estimated；压力使用上游边界代理，温度使用宿主气温代理。不是实测传感器或厂家精度验证。",
"精度界限仅在归零且宿主声明平衡时计算 max(0.006|Q|,0.001FS)；不生成误差分布，不从固定时长推断平衡。",
"标准流量和累计标准体积使用当前参考条件；改气体/参考条件使归零和读数失效并开启新累计量区间。",
"参考条件配置采用仿真定义：1 SLPM数值量程按当前参考条件解释；不声称复现厂商改变标准温压后内部标度处理。",
"气路节点引用由宿主保管。本适配器不做气源库存、守恒物质转移或压力网络求解，后续气路宿主需接入这些过程。",
"重放去重仅当前宿主内存有效，不声称跨重启恰好一次。API过滤不是Python或文件系统隔离。",
]
def export_alicat_mc_contract_metadata():
"""Type-only contract inputs; excludes all instance gas/boundary values."""
slots = _amc_copy.deepcopy(_AMC_SLOTS)
for sid, slot in slots.items():
slot["read_binding"] = "AlicatMCSession.read(instance_id=..., state_ids=['%s'])" % sid
if "standard" in sid or sid == "flow.setpoint_m3_s":
slot["reference_conditions"] = "Standard volume at gas.reference_temperature_K and gas.reference_pressure_Pa; defaults 298.15 K and 101325 Pa"
elif "pressure" in sid:
slot["reference_conditions"] = "Absolute pressure"
elif sid == "measurement.actual_flow_m3_s":
slot["reference_conditions"] = "Ideal-gas conversion at host upstream absolute pressure and gas temperature; no real gas correction"
arguments = {
"power.set": {"enabled": {"type": "boolean"}},
"gas.select": {"gas_id": {"type": "string", "description": "An explicitly host-registered compatible gas ID; no bundled gas library"}},
"gas.set_reference_conditions": {"temperature_K": {"type": "number", "exclusiveMinimum": 0, "x-unit": "K"}, "pressure_Pa": {"type": "number", "exclusiveMinimum": 0, "x-unit": "Pa"}},
"flow.set_setpoint": {"flow_rate_m3_s": {"type": "number", "minimum": 0, "maximum": ALICAT_MC_FS_M3_S, "x-unit": "m^3/s", "x-reference-conditions": "gas.reference_temperature_K, gas.reference_pressure_Pa", "description": "0 stops the target; positive values must be >= 0.0001 full scale"}},
"flow.zero": {}, "flow.reset_total": {}, "flow.read": {}, "control.set_pid": {},
}
direct = {"power.set": ["power.enabled"], "gas.select": ["gas.selected_id"],
"gas.set_reference_conditions": ["gas.reference_temperature_K", "gas.reference_pressure_Pa"],
"flow.set_setpoint": ["flow.setpoint_m3_s", "truth.equilibrium"], "flow.zero": ["flow.zeroed", "truth.standard_flow_m3_s"],
"flow.reset_total": ["truth.total_standard_volume_m3"], "flow.read": [], "control.set_pid": []}
summaries = {"power.set": "设置仿真供电；断电令测量不可用且归零失效，未假设失电阀位。",
"gas.select": "零目标下选用宿主登记气体；尚未接气路或宿主确认无流；清除归零和累计量区间。",
"gas.set_reference_conditions": "零目标下设置标准体积的参考温压；尚未接气路或宿主确认无流；清除归零和累计量区间。",
"flow.set_setpoint": "写入0或0.01–100%FS目标；成功不代表达到目标或平衡。",
"flow.zero": "只在宿主提供无流、平衡与有效边界条件时记录一次合成归零；不推进时间。",
"flow.reset_total": "清零仿真累计标准体积的显示区间，不转移或删除气体。",
"flow.read": "读取当前估计观测，不推进时间。",
"control.set_pid": "PID及真实阀曲线没有实现；没有编造增益单位或参数结构。"}
examples = {"power.set": {"enabled": True}, "gas.select": {"gas_id": "host_registered_compatible_gas"},
"gas.set_reference_conditions": {"temperature_K": 298.15, "pressure_Pa": 101325.0},
"flow.set_setpoint": {"flow_rate_m3_s": ALICAT_MC_FS_M3_S / 2},
"flow.zero": {}, "flow.reset_total": {}, "flow.read": {}, "control.set_pid": {}}
preconditions = {"power.set": [], "gas.select": ["已上电；目标为0；尚未接气路或宿主确认无流；gas_id由宿主登记兼容证据"],
"gas.set_reference_conditions": ["已上电；目标为0；尚未接气路或宿主确认无流；参考温压有限且大于0"],
"flow.set_setpoint": ["已上电且已选宿主登记气体；正目标须>=0.0001FS；写入目标不要求过程已就绪"],
"flow.zero": ["已上电且已选气体；目标为0；进出气节点已接入；有效温压；宿主no_flow及equilibrium均为true"],
"flow.reset_total": ["已上电"], "flow.read": [], "control.set_pid": []}
caps = {}
for cid, props in arguments.items():
effects = list(direct[cid])
if cid == "power.set":
effects += ["flow.zeroed", "truth.standard_flow_m3_s", "truth.total_standard_volume_m3"]
if cid in ("gas.select", "gas.set_reference_conditions"):
effects += ["flow.zeroed", "truth.standard_flow_m3_s", "truth.total_standard_volume_m3"]
if cid != "flow.read" and cid != "control.set_pid":
effects += _AMC_MEASUREMENTS
effect_entries = [{"state_id": sid, "timing": "immediate", "description_zh": "同步变更设定或刷新明确标注的观测代理"} for sid in dict.fromkeys(effects)]
if cid == "flow.set_setpoint":
immediate = ["flow.setpoint_m3_s", "truth.equilibrium", "measurement.accuracy_conditions_met", "measurement.standard_accuracy_bound_m3_s"]
future = ["truth.standard_flow_m3_s", "truth.total_standard_volume_m3", "measurement.standard_flow_m3_s", "measurement.actual_flow_m3_s", "measurement.mass_flow_kg_s", "measurement.total_standard_volume_m3"]
effect_entries = [{"state_id": sid, "timing": "immediate", "description_zh": "写入目标且撤销上次平衡状态的精度条件"} for sid in immediate]
effect_entries += [{"state_id": sid, "timing": "on_step", "description_zh": "仅在宿主显式配置动态及有效气路边界后，随共同时间推进简化流量响应和积分"} for sid in future]
result_ids = _AMC_MEASUREMENTS if cid == "flow.read" else direct[cid]
result_ids = [sid for sid in result_ids if slots[sid]["visibility"] == "agent"]
if cid == "flow.reset_total":
result_ids = ["measurement.total_standard_volume_m3"]
caps[cid] = {"availability": "unsupported" if cid == "control.set_pid" else "implemented", "visibility": "agent",
"kind": "query" if cid == "flow.read" else "configuration" if cid.startswith("gas.") else "device_command",
"description_zh": summaries[cid], "input_schema": _amc_obj(props),
"output_schema": _amc_obj({sid: _amc_copy.deepcopy(slots[sid]["value_schema"]) for sid in result_ids}),
"state_effects": effect_entries,
"observes": result_ids, "preconditions_zh": preconditions[cid], "example_arguments": [examples[cid]],
"binding": None if cid == "control.set_pid" else "basic40_runtime_automation.AlicatMCSession.invoke(instance_id=..., capability_id='%s', arguments=..., request_id=...)" % cid,
"model_effects": {"mode": "none", "binding_ids": [], "description_zh": "未实现屏幕跨层同步；内阀行程与机构未知，未用归一化参数假冒机械关节"}}
return {"asset_types": {ALICAT_MC_TYPE: {"catalog_id": "CHEM-180", "model": "Alicat Scientific MC, 1 SLPM, standard accuracy, Rev6 (2025-07)",
"asset_version": "1.1.0", "state_slots": slots, "capabilities": caps,
"parameters": {
"full_scale_standard_flow_m3_s": {"value": ALICAT_MC_FS_M3_S, "unit": "m^3/s", "evidence": "catalog"},
"minimum_positive_control_m3_s": {"value": ALICAT_MC_MIN_M3_S, "unit": "m^3/s", "evidence": "catalog"},
"fastest_control_t63_s": {"value": 0.03, "unit": "s", "evidence": "catalog", "note_zh": "配置与调整相关的最快T63，非稳定时间且不设为默认tau"},
"default_reference_temperature_K": {"value": 298.15, "unit": "K", "evidence": "catalog"},
"default_reference_pressure_Pa": {"value": 101325.0, "unit": "Pa", "evidence": "catalog"},
"default_dynamic_time_constant_s": {"value": None, "unit": "s", "evidence": "unknown"},
"gas_molar_mass_kg_mol": {"value": None, "unit": "kg/mol", "evidence": "unknown"},
"valve_travel_m": {"value": None, "unit": "m", "evidence": "unknown"},
"pid_gains": {"value": None, "unit": "1", "evidence": "unknown", "note_zh": "实际参数结构及单位未知；1仅为此未知占位项的合同单位"}},
"limitations": list(_AMC_LIMITATIONS)}},
"host_capabilities": {
"host.register_gas": {"binding": "AlicatMCRuntime.host_register_gas", "scope": "Trusted gas IDs and compatibility evidence; optional host molar mass evidence"},
"host.connect_ports": {"binding": "AlicatMCRuntime.host_connect_ports", "scope": "instance upstream inlet node -> MFC -> downstream outlet node; does not solve the network"},
"host.set_boundary": {"binding": "AlicatMCRuntime.host_set_boundary", "scope": "Trusted absolute pressures, temperature, no-flow and equilibrium assertions"},
"host.configure_dynamics": {"binding": "AlicatMCRuntime.host_configure_dynamics", "scope": "Explicit positive first-order tau and assumption evidence; no default tau"},
"sim.step": {"binding": "AlicatMCRuntime.host_step(dt_s)", "scope": "All registered MFC instances use one host clock; scheduling bound 0..3600s, not a vendor limit"}},
"result_schema_scope": "output_schema validates response.result; public observations never include truth.*"}
class AlicatMCRuntime:
"""Trusted host; state and deduplication are isolated per runtime/instance."""
def __init__(self):
self.time_s = 0.0
self._instances = {}
self._gases = {}
self._principals = {}
self._requests = {}
self._logs = {}
self._lock = _amc_threading.RLock()
def create_instance(self, instance_id, asset_type_id=ALICAT_MC_TYPE):
with self._lock:
if not isinstance(instance_id, str) or not instance_id or instance_id in self._instances or asset_type_id != ALICAT_MC_TYPE:
raise ValueError("Unique nonempty instance ID and CHEM-180 asset type required")
values = {sid: None for sid in _AMC_SLOTS}
values.update({"power.enabled": False, "gas.reference_temperature_K": 298.15, "gas.reference_pressure_Pa": 101325.0,
"flow.setpoint_m3_s": 0.0, "flow.zeroed": False, "simulation.dynamic_model_configured": False,
"measurement.accuracy_conditions_met": False, "truth.equilibrium": False, "truth.no_flow": False})
self._instances[instance_id] = {"instance_id": instance_id, "values": values, "revision": 0, "dynamics_evidence": None}
def register_principal(self, principal_id, *, visibility, instance_ids=None):
with self._lock:
if not isinstance(principal_id, str) or not principal_id or principal_id in self._principals or visibility not in ("agent", "debug", "evaluator"):
raise ValueError("Host-assigned principal must be unique and have a valid visibility")
if instance_ids is not None and (not isinstance(instance_ids, (list, tuple, set, frozenset)) or any(not isinstance(k, str) or k not in self._instances for k in instance_ids)):
raise ValueError("Invalid instance scope")
self._principals[principal_id] = (visibility, None if instance_ids is None else frozenset(instance_ids))
self._logs[principal_id] = []
def session(self, principal_id):
if not isinstance(principal_id, str) or principal_id not in self._principals:
raise ValueError("Host authentication and registration required")
return AlicatMCSession(self, principal_id)
def host_register_gas(self, gas_id, *, compatibility_evidence, molar_mass_kg_mol=None, property_evidence=None):
with self._lock:
if not isinstance(gas_id, str) or not gas_id.strip() or gas_id in self._gases or not isinstance(compatibility_evidence, str) or not compatibility_evidence.strip():
raise ValueError("Unique gas ID and compatibility evidence required")
if molar_mass_kg_mol is not None and (not _amc_number(molar_mass_kg_mol) or molar_mass_kg_mol <= 0 or not isinstance(property_evidence, str) or not property_evidence.strip()):
raise ValueError("Finite positive molar mass requires explicit property evidence")
self._gases[gas_id] = {"compatibility_evidence": compatibility_evidence,
"molar_mass_kg_mol": molar_mass_kg_mol, "property_evidence": property_evidence}
def host_enable_library_gas(self, gas_id, *, compatibility_evidence):
"""Template hook: trusted approval of an S-Series-only/unlisted library gas (standard-MC Gas Select gases need none)."""
return _amc_templates().host_enable_library_gas(self, gas_id, compatibility_evidence=compatibility_evidence)
def host_set_line_gas(self, instance_id, *, gas_id):
"""Template hook: trusted declaration of the library gas physically in the line (None = the selected gas)."""
return _amc_templates().host_set_line_gas(self, instance_id, gas_id=gas_id)
def _require(self, instance_id):
if not isinstance(instance_id, str) or instance_id not in self._instances:
raise ValueError("Unknown instance")
return self._instances[instance_id]
def _commit(self, inst, values):
self._refresh(values, inst)
if inst["values"] != values:
inst["values"] = values
inst["revision"] += 1
@staticmethod
def _boundaries_valid(s):
lower, upper = 11.5 * ALICAT_MC_PSI_PA, 160 * ALICAT_MC_PSI_PA
return (s["ports.upstream_node_id"] is not None and s["ports.downstream_node_id"] is not None
and all(_amc_number(s[key]) for key in ("truth.upstream_pressure_Pa", "truth.downstream_pressure_Pa", "truth.temperature_K"))
and lower <= s["truth.upstream_pressure_Pa"] <= upper and lower <= s["truth.downstream_pressure_Pa"] <= upper
and 263.15 <= s["truth.temperature_K"] <= 333.15)
@staticmethod
def _stopped_for_configuration(s):
unconnected = s["ports.upstream_node_id"] is None and s["ports.downstream_node_id"] is None
return s["flow.setpoint_m3_s"] == 0 and ((unconnected and s["truth.standard_flow_m3_s"] is None)
or (s["truth.no_flow"] and s["truth.standard_flow_m3_s"] in (None, 0)))
def _refresh(self, s, inst=None):
for sid in _AMC_MEASUREMENTS:
s[sid] = False if sid == "measurement.accuracy_conditions_met" else None
if not s["power.enabled"] or s["gas.selected_id"] is None or not self._boundaries_valid(s):
return
s["measurement.pressure_Pa"] = s["truth.upstream_pressure_Pa"]
s["measurement.temperature_K"] = s["truth.temperature_K"]
q = s["truth.standard_flow_m3_s"]
if not s["flow.zeroed"] or q is None:
return
if _amc_template_backed(self, s, inst): # template hook: library gas (NIST real-gas density, LFE viscosity)
return _amc_templates().refresh_readings(self, s, inst)
s["measurement.standard_flow_m3_s"] = q
s["measurement.actual_flow_m3_s"] = _amc_finite_result(q * (s["truth.temperature_K"] / s["gas.reference_temperature_K"]) * (s["gas.reference_pressure_Pa"] / s["truth.upstream_pressure_Pa"]))
molar_mass = self._gases[s["gas.selected_id"]]["molar_mass_kg_mol"]
if molar_mass is not None:
s["measurement.mass_flow_kg_s"] = _amc_finite_result(q * s["gas.reference_pressure_Pa"] * molar_mass / (ALICAT_MC_R * s["gas.reference_temperature_K"]))
s["measurement.total_standard_volume_m3"] = s["truth.total_standard_volume_m3"]
if s["truth.equilibrium"]:
s["measurement.accuracy_conditions_met"] = True
s["measurement.standard_accuracy_bound_m3_s"] = max(0.006 * abs(q), 0.001 * ALICAT_MC_FS_M3_S)
def host_connect_ports(self, instance_id, *, upstream_node_id, downstream_node_id):
with self._lock:
inst = self._require(instance_id)
if any(not isinstance(v, str) or not v.strip() for v in (upstream_node_id, downstream_node_id)) or upstream_node_id == downstream_node_id:
raise ValueError("Two distinct nonempty gas-network node IDs are required")
s = _amc_copy.deepcopy(inst["values"])
if s["ports.upstream_node_id"] == upstream_node_id and s["ports.downstream_node_id"] == downstream_node_id:
return
if not self._stopped_for_configuration(s):
raise ValueError("Stop flow before reconnecting topology")
s.update({"ports.upstream_node_id": upstream_node_id, "ports.downstream_node_id": downstream_node_id,
"flow.zeroed": False, "truth.standard_flow_m3_s": None, "truth.total_standard_volume_m3": None,
"truth.upstream_pressure_Pa": None, "truth.downstream_pressure_Pa": None, "truth.temperature_K": None,
"truth.no_flow": False, "truth.equilibrium": False})
self._commit(inst, s)
def host_set_boundary(self, instance_id, *, upstream_pressure_Pa, downstream_pressure_Pa, temperature_K, equilibrium, no_flow):
with self._lock:
inst = self._require(instance_id)
if any(not _amc_number(v) or v <= 0 for v in (upstream_pressure_Pa, downstream_pressure_Pa, temperature_K)) or type(equilibrium) is not bool or type(no_flow) is not bool:
raise ValueError("Positive finite SI boundaries and boolean host assertions required")
s = _amc_copy.deepcopy(inst["values"])
s.update({"truth.upstream_pressure_Pa": float(upstream_pressure_Pa), "truth.downstream_pressure_Pa": float(downstream_pressure_Pa),
"truth.temperature_K": float(temperature_K), "truth.equilibrium": equilibrium, "truth.no_flow": no_flow})
if no_flow:
s["truth.standard_flow_m3_s"] = 0.0
elif not self._boundaries_valid(s) or upstream_pressure_Pa <= downstream_pressure_Pa:
s["truth.standard_flow_m3_s"] = None
s["truth.total_standard_volume_m3"] = None
self._commit(inst, s)
def host_configure_dynamics(self, instance_id, *, time_constant_s, evidence):
with self._lock:
inst = self._require(instance_id)
if not _amc_number(time_constant_s) or time_constant_s <= 0 or not isinstance(evidence, str) or not evidence.strip():
raise ValueError("A positive finite assumed tau and explicit evidence are required")
s = _amc_copy.deepcopy(inst["values"])
if not self._stopped_for_configuration(s):
raise ValueError("Configure dynamics only while flow is stopped")
s["truth.response_time_constant_s"] = float(time_constant_s)
s["simulation.dynamic_model_configured"] = True
inst["dynamics_evidence"] = evidence
self._commit(inst, s)
def host_step(self, dt_s):
"""One common host time step; no gas inventory transaction is asserted."""
if not _amc_number(dt_s) or not 0 <= dt_s <= 3600:
raise ValueError("Host scheduling dt_s must be finite in [0,3600]")
if dt_s == 0:
return
with self._lock:
pending = []
for inst in self._instances.values():
s = _amc_copy.deepcopy(inst["values"])
old, tau = s["truth.standard_flow_m3_s"], s["truth.response_time_constant_s"]
ready = s["power.enabled"] and s["gas.selected_id"] is not None and s["flow.zeroed"] and self._boundaries_valid(s)
templated = ready and _amc_template_backed(self, s, inst) # template hook
factor = _amc_templates().indication_factor(self, s, inst) if templated else 1.0
ready = ready and factor is not None # condensed / outside library data: flow undefined
if ready and s["truth.no_flow"]:
s["truth.standard_flow_m3_s"] = 0.0
elif ready and tau is not None and old is not None and s["truth.upstream_pressure_Pa"] > s["truth.downstream_pressure_Pa"]:
target = s["flow.setpoint_m3_s"] / factor # controller servos on the indicated (k * true) flow; k=1.0 legacy
response = -_amc_math.expm1(-dt_s / tau)
s["truth.standard_flow_m3_s"] = max(0.0, old + (target - old) * response)
integral = old * dt_s + (target - old) * (dt_s - tau * response)
integral = min(max(integral, min(old, target) * dt_s), max(old, target) * dt_s)
if s["truth.total_standard_volume_m3"] is not None:
if templated:
_amc_templates().totalize(inst, s["truth.total_standard_volume_m3"], integral, factor)
s["truth.total_standard_volume_m3"] += integral
else:
s["truth.standard_flow_m3_s"] = None
s["truth.total_standard_volume_m3"] = None
self._refresh(s, inst)
pending.append((inst, s))
self.time_s += dt_s
for inst, s in pending:
self._commit(inst, s)
def debug_snapshot(self):
with self._lock:
return _amc_copy.deepcopy({"time_s": self.time_s, "instances": self._instances, "gases": self._gases})
class AlicatMCSession:
"""Filtered public API. Identity is fixed by the trusted host registry."""
def __init__(self, host, principal_id):
self.__host = host
self.__principal_id = principal_id
def _instance(self, instance_id):
if not isinstance(instance_id, str):
return None
inst = self.__host._instances.get(instance_id)
_, scope = self.__host._principals[self.__principal_id]
return inst if inst and (scope is None or instance_id in scope) else None
def _visible(self, sid):
role, _ = self.__host._principals[self.__principal_id]
return sid in _AMC_SLOTS and (_AMC_SLOTS[sid]["visibility"] == "agent" or role in ("debug", "evaluator"))
def _envelope(self, instance_id, request_id=None, *, status="succeeded", result=None, observations=None, error=None):
inst = self._instance(instance_id)
return {"protocol_version": "1.0.0", "instance_id": instance_id if isinstance(instance_id, str) else None,
"request_id": request_id if isinstance(request_id, str) else None, "operation_id": None, "status": status,
"state_revision": inst["revision"] if inst else None, "clock": {"domain": "simulation", "time_s": self.__host.time_s},
"result": {} if result is None else _amc_copy.deepcopy(result), "observations": {} if observations is None else observations, "error": error}
def _error(self, instance_id, code, request_id=None, status="rejected"):
messages = {"UNKNOWN_INSTANCE": "Instance is unavailable in this session.", "UNKNOWN_CAPABILITY": "Capability is unavailable for this asset.",
"INVALID_ARGUMENT": "Arguments do not meet the declared schema or limits.", "PRECONDITION_FAILED": "Required operating configuration or state is unavailable.",
"ACCESS_DENIED": "Requested operation is outside the session access policy.", "REQUEST_CONFLICT": "Request ID already identifies a different logical request.",
"UNSUPPORTED": "This capability has no executable implementation."}
return self._envelope(instance_id, request_id, status=status,
error={"code": code, "message": messages[code], "retryable": False, "side_effects": "none", "progress": None})
def describe(self, *, asset_type_id=None, instance_id=None):
with self.__host._lock:
if (asset_type_id is None) == (instance_id is None):
return self._error(None, "INVALID_ARGUMENT")
if instance_id is not None:
if self._instance(instance_id) is None:
return self._error(instance_id, "UNKNOWN_INSTANCE")
asset_type_id = ALICAT_MC_TYPE
if asset_type_id != ALICAT_MC_TYPE:
return self._error(instance_id, "INVALID_ARGUMENT")
_, scope = self.__host._principals[self.__principal_id]
if scope is not None and not scope:
return self._error(instance_id, "ACCESS_DENIED")
spec = export_alicat_mc_contract_metadata()["asset_types"][ALICAT_MC_TYPE]
_amc_templates().augment_describe(spec) # template hook: library queries + gas.select library IDs
spec["state_slots"] = {sid: value for sid, value in spec["state_slots"].items() if self._visible(sid)}
# Capability effects are metadata too: hide restricted slot identifiers.
for cap in spec["capabilities"].values():
cap["state_effects"] = [e for e in cap["state_effects"] if self._visible(e["state_id"])]
spec.update({"protocol_version": "1.0.0", "asset_type_id": ALICAT_MC_TYPE, "instance_id": instance_id, "adapter": "basic40_runtime_automation.AlicatMCSession"})
return spec
def read(self, *, instance_id, state_ids=None):
with self.__host._lock:
inst = self._instance(instance_id)
if inst is None:
return self._error(instance_id, "UNKNOWN_INSTANCE")
if state_ids is None:
state_ids = [sid for sid in _AMC_SLOTS if self._visible(sid)]
if not isinstance(state_ids, list) or any(not isinstance(sid, str) for sid in state_ids) or len(set(state_ids)) != len(state_ids):
return self._error(instance_id, "INVALID_ARGUMENT")
if any(not self._visible(sid) for sid in state_ids):
return self._error(instance_id, "ACCESS_DENIED")
observations = {}
for sid in state_ids:
value = _amc_copy.deepcopy(inst["values"][sid])
observations[sid] = {"value": value, "unit": _AMC_SLOTS[sid]["unit"],
"quality": "unavailable" if value is None else "estimated" if _AMC_SLOTS[sid]["origin"] == "derived" else "valid",
"sample_time_s": self.__host.time_s, "sample_window_s": None}
if value is None:
observations[sid]["reason"] = "Required configuration, supported process model or property evidence is unavailable."
return self._envelope(instance_id, observations=observations)
def invoke(self, *, instance_id, capability_id, arguments, request_id):
with self.__host._lock:
inst = self._instance(instance_id)
if inst is None:
return self._error(instance_id, "UNKNOWN_INSTANCE", request_id)
if not isinstance(capability_id, str) or not isinstance(arguments, dict) or not isinstance(request_id, str) or not request_id or len(request_id) > 256:
return self._error(instance_id, "INVALID_ARGUMENT", request_id)
try:
digest = _amc_hashlib.sha256(_amc_json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False, separators=(",", ":")).encode()).hexdigest()
except (TypeError, ValueError, OverflowError, RecursionError):
return self._error(instance_id, "INVALID_ARGUMENT", request_id)
key = (self.__principal_id, instance_id, request_id)
if key in self.__host._requests:
previous_digest, response = self.__host._requests[key]
return _amc_copy.deepcopy(response) if digest == previous_digest else self._error(instance_id, "REQUEST_CONFLICT", request_id)
response = self._invoke_checked(inst, capability_id, arguments, request_id)
self.__host._requests[key] = (digest, _amc_copy.deepcopy(response))
self.__host._logs[self.__principal_id].append({"instance_id": instance_id, "capability_id": capability_id, "request_id": request_id, "response": _amc_copy.deepcopy(response)})
return response
def _invoke_checked(self, inst, cid, args, request_id):
sid = inst["instance_id"]
fail = lambda code, status="rejected": self._error(sid, code, request_id, status)
metadata = export_alicat_mc_contract_metadata()["asset_types"][ALICAT_MC_TYPE]["capabilities"]
if cid in _AMC_TEMPLATE_CAPABILITIES: # template hook: read-only public library queries
return _amc_templates().invoke(self, self.__host, inst, cid, args, request_id)
if cid not in metadata:
return fail("UNKNOWN_CAPABILITY")
if cid == "control.set_pid":
return fail("UNSUPPORTED", "unsupported")
props = metadata[cid]["input_schema"]["properties"]
if set(args) != set(props):
return fail("INVALID_ARGUMENT")
for name, spec in props.items():
value = args[name]
if spec["type"] == "number" and (not _amc_number(value) or ("minimum" in spec and value < spec["minimum"]) or ("maximum" in spec and value > spec["maximum"]) or ("exclusiveMinimum" in spec and value <= spec["exclusiveMinimum"])):
return fail("INVALID_ARGUMENT")
if spec["type"] == "boolean" and type(value) is not bool:
return fail("INVALID_ARGUMENT")
if spec["type"] == "string" and (not isinstance(value, str) or not value.strip()):
return fail("INVALID_ARGUMENT")
s = _amc_copy.deepcopy(inst["values"])
if cid not in ("power.set", "flow.read") and not s["power.enabled"]:
return fail("PRECONDITION_FAILED")
if cid in ("gas.select", "gas.set_reference_conditions") and not self.__host._stopped_for_configuration(s):
return fail("PRECONDITION_FAILED")
if cid == "power.set":
s["power.enabled"] = args["enabled"]
if not args["enabled"]:
s.update({"flow.zeroed": False, "truth.standard_flow_m3_s": None, "truth.total_standard_volume_m3": None})
elif cid == "gas.select":
if args["gas_id"] not in self.__host._gases and not _amc_templates().is_selectable(self.__host, args["gas_id"]): # template hook
return fail("PRECONDITION_FAILED")
s["gas.selected_id"] = args["gas_id"]
s.update({"flow.zeroed": False, "truth.standard_flow_m3_s": None, "truth.total_standard_volume_m3": None})
elif cid == "gas.set_reference_conditions":
s["gas.reference_temperature_K"], s["gas.reference_pressure_Pa"] = float(args["temperature_K"]), float(args["pressure_Pa"])
s.update({"flow.zeroed": False, "truth.standard_flow_m3_s": None, "truth.total_standard_volume_m3": None})
elif cid == "flow.set_setpoint":
value = args["flow_rate_m3_s"]
if 0 < value < ALICAT_MC_MIN_M3_S:
return fail("INVALID_ARGUMENT")
if s["gas.selected_id"] is None:
return fail("PRECONDITION_FAILED")
if s["flow.setpoint_m3_s"] != value:
s["truth.equilibrium"] = False
s["flow.setpoint_m3_s"] = float(value)
elif cid == "flow.zero":
if not (s["gas.selected_id"] is not None and s["flow.setpoint_m3_s"] == 0 and s["truth.no_flow"] and s["truth.equilibrium"] and self.__host._boundaries_valid(s)):
return fail("PRECONDITION_FAILED")
s["flow.zeroed"] = True
s["truth.standard_flow_m3_s"] = 0.0
elif cid == "flow.reset_total":
s["truth.total_standard_volume_m3"] = 0.0
self.__host._commit(inst, s)
result = {key: inst["values"][key] for key in metadata[cid]["output_schema"]["properties"]}
return self._envelope(sid, request_id, result=result)
def write(self, *, instance_id, state_id, value, request_id):
with self.__host._lock:
if self._instance(instance_id) is None:
return self._error(instance_id, "UNKNOWN_INSTANCE", request_id)
if not isinstance(state_id, str) or not self._visible(state_id) or _AMC_SLOTS[state_id]["access"] != "read_write":
return self._error(instance_id, "ACCESS_DENIED", request_id)
route = _AMC_SLOTS[state_id]["write_via"]
return self.invoke(instance_id=instance_id, capability_id=route["capability_id"], arguments={route["parameter"]: value}, request_id=request_id)
def logs(self):
with self.__host._lock:
return _amc_copy.deepcopy(self.__host._logs[self.__principal_id])
# END CHEM-180 ALICAT MC APPEND-ONLY RUNTIME
# CHEM-181 P-702CV batch-scope runtime; appended as a self-contained namespace.
import copy as _p702cv_copy
import json as _p702cv_json
import math as _p702cv_math
import threading as _p702cv_threading
P702CV_ASSET_TYPE_ID = 'instrument.bronkhorst_p702cv_5bar_gauge_n2'
P702CV_SENSOR_FULL_SCALE_PA = 500000.0
P702CV_MEASUREMENT_MIN_PA = 10000.0
P702CV_CONTROL_MIN_PA = 100000.0
P702CV_GAS_CONSTANT = 8.31446261815324
def _p702cv_number(value):
if isinstance(value, bool) or not isinstance(value, (int, float)):
return False
try:
return _p702cv_math.isfinite(value)
except (ValueError, OverflowError):
return False
def _p702cv_num(unit, minimum=None, maximum=None, nullable=False):
s = {'type': 'number', 'x-unit': unit}
if minimum is not None:
s['minimum'] = minimum
if maximum is not None:
s['maximum'] = maximum
return {'anyOf': [s, {'type': 'null'}]} if nullable else s
def _p702cv_obj(properties):
return {'type': 'object', 'properties': properties, 'required': list(properties), 'additionalProperties': False}
def export_p702cv_contract_metadata():
"""Type metadata and executable input/output schemas; no live state values."""
number = _p702cv_num
flag = {'type': 'boolean'}
enum = lambda values: {'type': 'string', 'enum': values}
scalar = {'type': 'number', 'x-unit': '1'}
defs = {
'power.set': ({'enabled': flag}, {'enabled': flag}, {'enabled': True}, ['power.enabled', 'valve.opening', 'control.status', 'pressure.reading_pa', 'pressure.deviation_pa', 'process.outflow_mol_s'], ['electronics', 'control_valve', 'pressure_sensor'], 'agent'),
'pressure.set_setpoint': ({'pressure_Pa': number('Pa', 100000, 500000)}, {'pressure_Pa': number('Pa', 100000, 500000)}, {'pressure_Pa': 200000.0}, ['pressure.setpoint_pa', 'pressure.active_setpoint_pa', 'pressure.deviation_pa'], ['electronics'], 'agent'),
'control.set_mode': ({'mode': enum(['manual', 'automatic'])}, {'mode': enum(['manual', 'automatic'])}, {'mode': 'manual'}, ['control.mode', 'control.status'], ['electronics', 'control_valve'], 'agent'),
'control.set_gain': ({'gain_per_Pa_s': number('1/(Pa*s)', 0)}, {'gain_per_Pa_s': number('1/(Pa*s)', 0)}, {'gain_per_Pa_s': 0.000001}, ['control.gain_per_pa_s'], ['electronics'], 'agent'),
'control.set_ramp_rate': ({'rate_Pa_s': number('Pa/s', 0, nullable=True)}, {'rate_Pa_s': number('Pa/s', 0, nullable=True)}, {'rate_Pa_s': 10000.0}, ['control.ramp_rate_pa_s'], ['electronics'], 'agent'),
'valve.set_opening': ({'opening': number('1', 0, 1)}, {'opening': number('1', 0, 1)}, {'opening': 0.5}, ['valve.opening', 'process.outflow_mol_s'], ['control_valve'], 'agent'),
'scene.set_valve_position': ({'position': number('1', 0, 1)}, {'position': number('1', 0, 1)}, {'position': 0.5}, ['scene.valve_position'], ['control_valve'], 'agent'),
'simulation.step': ({'dt_s': number('s', 1e-9, 3600), 'world_time_s': number('s', 0)}, {'world_time_s': number('s', 0)}, {'dt_s': 0.1, 'world_time_s': 0.1}, ['pressure.active_setpoint_pa', 'valve.opening', 'control.status', 'pressure.reading_pa', 'pressure.deviation_pa', 'process.upstream_absolute_pressure_pa', 'process.upstream_moles_mol', 'process.outflow_mol_s', 'process.integrated_inflow_mol', 'process.integrated_outflow_mol'], ['flow_body', 'control_valve', 'pressure_sensor', 'electronics'], 'debug'),
'simulation.set_boundary': ({'inflow_mol_s': number('mol/s', 0), 'downstream_absolute_pressure_Pa': number('Pa', 0)}, {'boundary_updated': flag}, {'inflow_mol_s': 0.0001, 'downstream_absolute_pressure_Pa': 101325.0}, ['process.inflow_mol_s', 'process.downstream_absolute_pressure_pa', 'process.outflow_mol_s'], ['flow_body'], 'debug'),
}
caps = {}
for key, (inp, out, example, effects, components, visibility) in defs.items():
caps[key] = {'input_schema': _p702cv_obj(inp), 'output_schema': _p702cv_obj(out), 'example_arguments': example, 'state_effects': effects, 'component_ids': components, 'visibility': visibility}
slots = {
'power.enabled': (flag, '1', 'setpoint', 'agent', 'power.set', 'enabled', ['electronics']),
'pressure.setpoint_pa': (number('Pa', 100000, 500000, True), 'Pa', 'setpoint', 'agent', 'pressure.set_setpoint', 'pressure_Pa', ['electronics']),
'pressure.active_setpoint_pa': (number('Pa', 100000, 500000, True), 'Pa', 'derived', 'agent', None, None, ['electronics']),
'pressure.reading_pa': (number('Pa', 10000, 500000, True), 'Pa', 'sensor', 'agent', None, None, ['pressure_sensor']),
'pressure.deviation_pa': (number('Pa', nullable=True), 'Pa', 'derived', 'agent', None, None, ['electronics']),
'control.mode': (enum(['manual', 'automatic']), '1', 'setpoint', 'agent', 'control.set_mode', 'mode', ['electronics']),
'control.gain_per_pa_s': (number('1/(Pa*s)', 0), '1/(Pa*s)', 'setpoint', 'agent', 'control.set_gain', 'gain_per_Pa_s', ['electronics']),
'control.ramp_rate_pa_s': (number('Pa/s', 0, nullable=True), 'Pa/s', 'setpoint', 'agent', 'control.set_ramp_rate', 'rate_Pa_s', ['electronics']),
'control.status': (enum(['power_off', 'manual', 'regulating', 'sensor_unavailable']), '1', 'derived', 'agent', None, None, ['electronics']),
'valve.opening': (number('1', 0, 1), '1', 'derived', 'agent', 'valve.set_opening', 'opening', ['control_valve']),
'scene.valve_position': (number('1', 0, 1), '1', 'scene', 'agent', 'scene.set_valve_position', 'position', ['control_valve']),
'process.upstream_absolute_pressure_pa': (number('Pa', 0), 'Pa', 'process_truth', 'debug', None, None, ['flow_body']),
'process.upstream_moles_mol': (number('mol', 0), 'mol', 'process_truth', 'debug', None, None, ['flow_body']),
'process.inflow_mol_s': (number('mol/s', 0), 'mol/s', 'process_truth', 'debug', None, None, ['flow_body']),
'process.downstream_absolute_pressure_pa': (number('Pa', 0), 'Pa', 'process_truth', 'debug', None, None, ['flow_body']),
'process.outflow_mol_s': (number('mol/s', 0), 'mol/s', 'process_truth', 'debug', None, None, ['flow_body']),
'process.integrated_inflow_mol': (number('mol', 0), 'mol', 'process_truth', 'debug', None, None, ['flow_body']),
'process.integrated_outflow_mol': (number('mol', 0), 'mol', 'process_truth', 'debug', None, None, ['flow_body']),
}
state_slots = {}
for key, (schema, unit, origin, visibility, write_cap, argument, components) in slots.items():
state_slots[key] = {'value_schema': schema, 'unit': unit, 'origin': origin, 'visibility': visibility, 'write_via': None if write_cap is None else {'capability_id': write_cap, 'argument': argument, 'fixed_arguments': {}}, 'component_ids': components}
return {'asset_type_id': P702CV_ASSET_TYPE_ID, 'state_slots': state_slots, 'capabilities': caps,
'configuration': {'gas': 'N2', 'pressure_mode': 'gauge', 'sensor_min_Pa': 0.0, 'sensor_full_scale_Pa': 500000.0, 'measurement_valid_min_Pa': 10000.0, 'control_setpoint_min_Pa': 100000.0, 'configuration_evidence': 'assumption; fixed for this asset, not a confirmed ordering code', 'sensor_response_s': 0.002, 'sensor_response_scope': 'manufacturer sensor-only figure; no dynamic sensor lag or full-loop settling-time model', 'vendor_valve_Kv': None, 'actual_valve_stroke_m': None, 'closed_loop_response_s': None},
'limits': ['Host must supply process volume, temperature, initial absolute pressure, downstream absolute pressure, inflow, linear valve conductance, gauge reference and control gain; these are scenario values, not vendor component specifications.', 'Ideal isothermal N2 gas only: no liquid, real-gas, choking, reverse flow, leakage, noise, hysteresis or calibrated valve characteristic.', 'Discrete integral output control is a simulation assumption; stability and step size depend on explicit host parameters.', 'Power-off forces modeled outlet opening to zero as a scenario assumption; unpowered gas accumulation still occurs. Real fail-safe state is unknown.', 'Scene valve position is independent normalized explanatory state; no process-to-scene actuation or physical valve stroke is claimed.', 'Agent API filtering is implemented; trusted Python host introspection and file access are outside this boundary.', 'Idempotency is per principal and instance in memory only; no cross-restart exactly-once promise.']}
class P702CVRuntime:
"""One host-owned instance. Public describe/read/invoke/write use agent visibility.
The host constructs authenticated sessions and supplies explicit scenario inputs.
The default world time is zero, power is off, manual opening is closed and no
pressure target is configured. These are simulation initialization choices.
"""
def __init__(self, instance_id, *, upstream_volume_m3, temperature_K,
initial_upstream_absolute_pressure_Pa, downstream_absolute_pressure_Pa,
inflow_mol_s, valve_conductance_mol_s_Pa, pressure_reference_Pa,
control_gain_per_Pa_s, scene_adapter=None, initial_world_time_s=0.0):
if not isinstance(instance_id, str) or not instance_id:
raise ValueError('A nonempty instance_id is required')
params = {'upstream_volume_m3': upstream_volume_m3, 'temperature_K': temperature_K,
'initial_upstream_absolute_pressure_Pa': initial_upstream_absolute_pressure_Pa,
'downstream_absolute_pressure_Pa': downstream_absolute_pressure_Pa,
'inflow_mol_s': inflow_mol_s, 'valve_conductance_mol_s_Pa': valve_conductance_mol_s_Pa,
'pressure_reference_Pa': pressure_reference_Pa, 'control_gain_per_Pa_s': control_gain_per_Pa_s,
'initial_world_time_s': initial_world_time_s}
if not all(_p702cv_number(v) and v >= 0 for v in params.values()):
raise ValueError('Scenario inputs must be finite nonnegative numbers')
if upstream_volume_m3 <= 0 or temperature_K <= 0 or valve_conductance_mol_s_Pa <= 0:
raise ValueError('Volume, temperature and linear conductance must be positive')
if not 263.15 <= temperature_K <= 343.15:
raise ValueError('Temperature outside specified operating interval')
if scene_adapter is not None and not callable(scene_adapter):
raise ValueError('scene_adapter must be callable')
self.instance_id = instance_id
self._config = {k: float(params[k]) for k in ['upstream_volume_m3', 'temperature_K', 'valve_conductance_mol_s_Pa', 'pressure_reference_Pa']}
self._rt_over_v = P702CV_GAS_CONSTANT * temperature_K / upstream_volume_m3
moles = initial_upstream_absolute_pressure_Pa / self._rt_over_v
if not _p702cv_number(self._rt_over_v) or self._rt_over_v <= 0 or not _p702cv_number(moles):
raise ValueError('Scenario is outside numerical support')
self._state = {'power.enabled': False, 'pressure.setpoint_pa': None, 'pressure.active_setpoint_pa': None,
'pressure.reading_pa': None, 'pressure.deviation_pa': None,
'control.mode': 'manual', 'control.gain_per_pa_s': float(control_gain_per_Pa_s),
'control.ramp_rate_pa_s': None, 'control.status': 'power_off',
'valve.opening': 0.0, 'scene.valve_position': 0.0,
'process.upstream_absolute_pressure_pa': float(initial_upstream_absolute_pressure_Pa),
'process.upstream_moles_mol': moles,
'process.inflow_mol_s': float(inflow_mol_s),
'process.downstream_absolute_pressure_pa': float(downstream_absolute_pressure_Pa),
'process.outflow_mol_s': 0.0, 'process.integrated_inflow_mol': 0.0, 'process.integrated_outflow_mol': 0.0}
self._time_s = float(initial_world_time_s)
self._revision = 0
self._scene_adapter = scene_adapter
self._principals = {'__agent__': 'agent'}
self._requests = {}
self._lock = _p702cv_threading.RLock()
self._metadata = export_p702cv_contract_metadata()
def register_principal(self, principal_id, *, visibility):
with self._lock:
if not isinstance(principal_id, str) or not principal_id or principal_id in self._principals or visibility not in ('agent', 'debug', 'evaluator'):
raise ValueError('New host-authenticated principal and visibility required')
self._principals[principal_id] = visibility
def session(self, principal_id):
if not isinstance(principal_id, str) or principal_id not in self._principals:
raise ValueError('Principal must first be registered by the host')
return P702CVSession(self, principal_id)
def describe(self, *, asset_type_id=None, instance_id=None):
return self.session('__agent__').describe(asset_type_id=asset_type_id, instance_id=instance_id)
def read(self, *, state_ids=None, instance_id=None):
return self.session('__agent__').read(state_ids=state_ids, instance_id=instance_id)
def invoke(self, *, capability_id, arguments, request_id, instance_id=None):
return self.session('__agent__').invoke(capability_id=capability_id, arguments=arguments, request_id=request_id, instance_id=instance_id)
def write(self, *, state_id, value, request_id, instance_id=None):
return self.session('__agent__').write(state_id=state_id, value=value, request_id=request_id, instance_id=instance_id)
def debug_snapshot(self):
with self._lock:
return _p702cv_copy.deepcopy({'state': self._state, 'configuration': self._config, 'state_revision': self._revision, 'world_time_s': self._time_s})
def sync_scene(self):
"""Trusted scene adapter receives only explanatory normalized position."""
with self._lock:
if self._scene_adapter is None:
raise RuntimeError('No scene adapter is registered')
self._scene_adapter(self.instance_id, {'scene.valve_position': self._state['scene.valve_position']})
def _observe(self, state):
pg = state['process.upstream_absolute_pressure_pa'] - self._config['pressure_reference_Pa']
valid = state['power.enabled'] and P702CV_MEASUREMENT_MIN_PA <= pg <= P702CV_SENSOR_FULL_SCALE_PA
state['pressure.reading_pa'] = pg if valid else None
target = state['pressure.active_setpoint_pa']
state['pressure.deviation_pa'] = pg - target if valid and target is not None else None
state['control.status'] = 'power_off' if not state['power.enabled'] else 'manual' if state['control.mode'] == 'manual' else 'regulating' if valid else 'sensor_unavailable'
state['process.outflow_mol_s'] = self._config['valve_conductance_mol_s_Pa'] * state['valve.opening'] * max(state['process.upstream_absolute_pressure_pa'] - state['process.downstream_absolute_pressure_pa'], 0.0)
def set_boundary(self, *, inflow_mol_s, downstream_absolute_pressure_Pa):
"""Trusted host updates fixed boundary for the next step; no time advance."""
with self._lock:
if not all(_p702cv_number(x) and x >= 0 for x in (inflow_mol_s, downstream_absolute_pressure_Pa)):
raise ValueError('Finite nonnegative boundary inputs required')
state = _p702cv_copy.deepcopy(self._state)
state['process.inflow_mol_s'] = float(inflow_mol_s)
state['process.downstream_absolute_pressure_pa'] = float(downstream_absolute_pressure_Pa)
self._observe(state)
if not _p702cv_number(state['process.outflow_mol_s']):
raise ValueError('Boundary outside numerical support')
self._state = state
self._revision += 1
return {'boundary_updated': True}
def step(self, dt_s, *, world_time_s):
"""Advance only when trusted host supplies contiguous common-world time.
Fixed opening per host step. q=C*u*max(p_up-p_down,0). The positive
pressure-difference branch is integrated analytically; a below-downstream
initial state first accumulates gas until it reaches downstream pressure.
"""
with self._lock:
if not _p702cv_number(dt_s) or not 1e-9 <= dt_s <= 3600 or not _p702cv_number(world_time_s) or world_time_s < 0:
raise ValueError('Invalid host step or clock')
if world_time_s <= self._time_s or not _p702cv_math.isclose(world_time_s, self._time_s + dt_s, rel_tol=0.0, abs_tol=1e-9):
raise ValueError('Host clock must be contiguous with this instance')
s = _p702cv_copy.deepcopy(self._state)
target = s['pressure.setpoint_pa']
active = s['pressure.active_setpoint_pa']
if target is not None and active is not None:
rate = s['control.ramp_rate_pa_s']
s['pressure.active_setpoint_pa'] = target if rate is None else active + max(-rate * dt_s, min(rate * dt_s, target - active))
if s['power.enabled'] and s['control.mode'] == 'automatic' and s['pressure.reading_pa'] is not None:
error = s['pressure.reading_pa'] - s['pressure.active_setpoint_pa']
change = s['control.gain_per_pa_s'] * error * dt_s
if not _p702cv_number(change):
raise ValueError('Control update outside numerical support')
s['valve.opening'] = min(1.0, max(0.0, s['valve.opening'] + change))
p0 = s['process.upstream_absolute_pressure_pa']
pd = s['process.downstream_absolute_pressure_pa']
qin = s['process.inflow_mol_s']
k = self._config['valve_conductance_mol_s_Pa'] * s['valve.opening']
a = self._rt_over_v
duration = dt_s
p_start = p0
if k == 0:
p1 = p0 + a * qin * duration
else:
if p_start < pd:
if qin == 0:
duration = 0.0
else:
hit_time = (pd - p_start) / (a * qin)
used = min(duration, hit_time)
p_start += a * qin * used
duration -= used
if duration <= 0:
p1 = p_start
else:
fraction = -_p702cv_math.expm1(-a * k * duration)
p1 = p_start + (pd - p_start + qin / k) * fraction
moles1 = p1 / a
inflow = qin * dt_s
outflow = s['process.upstream_moles_mol'] + inflow - moles1
tolerance = 1e-12 * max(1.0, s['process.upstream_moles_mol'], inflow)
if outflow < -tolerance:
raise ValueError('Gas balance outside numerical support')
if outflow < 0:
outflow = 0.0
moles1 = s['process.upstream_moles_mol'] + inflow
p1 = moles1 * a
s['process.upstream_absolute_pressure_pa'] = p1
s['process.upstream_moles_mol'] = moles1
s['process.integrated_inflow_mol'] += inflow
s['process.integrated_outflow_mol'] += outflow
self._observe(s)
if not all(v is None or isinstance(v, bool) or not isinstance(v, (int, float)) or _p702cv_number(v) for v in s.values()):
raise ValueError('Host step outside numerical support')
self._state = s
self._time_s = float(world_time_s)
self._revision += 1
return {'world_time_s': self._time_s}
class P702CVSession:
"""Visibility derives from host registration, never from user arguments."""
def __init__(self, runtime, principal_id):
self._runtime = runtime
self._principal_id = principal_id
def _visible(self, entry):
return entry['visibility'] == 'agent' or self._runtime._principals[self._principal_id] in ('debug', 'evaluator')
def _envelope(self, *, status='succeeded', result=None, observations=None, error=None, request_id=None):
r = self._runtime
return {'protocol_version': '1.0.0', 'instance_id': r.instance_id, 'request_id': request_id if isinstance(request_id, str) else None,
'operation_id': None, 'status': status, 'state_revision': r._revision,
'clock': {'domain': 'simulation', 'time_s': r._time_s}, 'result': result or {}, 'observations': observations or {}, 'error': error}
def _error(self, code, request_id=None, side_effects='none'):
messages = {'UNKNOWN_INSTANCE': 'Instance unavailable', 'UNKNOWN_CAPABILITY': 'Capability unavailable', 'ACCESS_DENIED': 'Requested resource is unavailable to this session', 'INVALID_ARGUMENT': 'Arguments do not match the supported schema', 'PRECONDITION_FAILED': 'Operation preconditions are not satisfied', 'REQUEST_CONFLICT': 'Request identifier was used with another payload', 'UNSUPPORTED': 'Required adapter is not registered', 'DEVICE_ERROR': 'Scene adapter failed; external state is uncertain'}
return self._envelope(status='unsupported' if code == 'UNSUPPORTED' else 'failed' if code == 'DEVICE_ERROR' else 'rejected', error={'code': code, 'message': messages[code], 'retryable': False, 'side_effects': side_effects}, request_id=request_id)
def _instance_ok(self, instance_id):
return instance_id is None or isinstance(instance_id, str) and instance_id == self._runtime.instance_id
def describe(self, *, asset_type_id=None, instance_id=None):
r = self._runtime
with r._lock:
if asset_type_id is not None and instance_id is not None:
return self._error('INVALID_ARGUMENT')
if not self._instance_ok(instance_id) or asset_type_id is not None and asset_type_id != P702CV_ASSET_TYPE_ID:
return self._error('UNKNOWN_INSTANCE')
meta = _p702cv_copy.deepcopy(r._metadata)
meta['state_slots'] = {k: v for k, v in meta['state_slots'].items() if self._visible(v)}
meta['capabilities'] = {k: v for k, v in meta['capabilities'].items() if self._visible(v)}
for capability in meta['capabilities'].values():
capability['state_effects'] = [key for key in capability['state_effects'] if key in meta['state_slots']]
return meta
def read(self, *, state_ids=None, instance_id=None):
r = self._runtime
with r._lock:
if not self._instance_ok(instance_id):
return self._error('UNKNOWN_INSTANCE')
visible = {k: v for k, v in r._metadata['state_slots'].items() if self._visible(v)}
ids = list(visible) if state_ids is None else state_ids
if not isinstance(ids, list) or any(not isinstance(k, str) for k in ids):
return self._error('INVALID_ARGUMENT')
if any(k not in visible for k in ids):
return self._error('ACCESS_DENIED')
observations = {}
for key in ids:
value = r._state[key]
unavailable = value is None
sensor = key in ('pressure.reading_pa', 'pressure.deviation_pa')
reason = ('power_off' if not r._state['power.enabled'] else 'outside_selected_measurement_range' if r._state['pressure.reading_pa'] is None else 'setpoint_unconfigured') if unavailable and sensor else 'not_configured' if unavailable else None
observations[key] = {'value': _p702cv_copy.deepcopy(value), 'unit': visible[key]['unit'], 'quality': 'unavailable' if unavailable else 'estimated' if sensor or key == 'valve.opening' else 'valid', 'sample_time_s': r._time_s, 'sample_window_s': None, 'unavailable_reason': reason}
return self._envelope(observations=observations)
@staticmethod
def _validate(schema, value):
if 'anyOf' in schema:
return any(P702CVSession._validate(part, value) for part in schema['anyOf'])
kind = schema['type']
if kind == 'null':
return value is None
if kind == 'number':
return _p702cv_number(value) and ('minimum' not in schema or value >= schema['minimum']) and ('maximum' not in schema or value <= schema['maximum'])
if kind == 'boolean':
return isinstance(value, bool)
if kind == 'string':
return isinstance(value, str) and ('enum' not in schema or value in schema['enum'])
if kind == 'object':
return isinstance(value, dict) and set(value) == set(schema['properties']) and all(P702CVSession._validate(sub, value[key]) for key, sub in schema['properties'].items())
return False
def write(self, *, state_id, value, request_id, instance_id=None):
r = self._runtime
with r._lock:
if not self._instance_ok(instance_id):
return self._error('UNKNOWN_INSTANCE', request_id)
spec = r._metadata['state_slots'].get(state_id) if isinstance(state_id, str) else None
if spec is None or not self._visible(spec) or spec['write_via'] is None:
return self._error('ACCESS_DENIED', request_id)
route = spec['write_via']
return self.invoke(capability_id=route['capability_id'], arguments={route['argument']: value}, request_id=request_id, instance_id=instance_id)
def invoke(self, *, capability_id, arguments, request_id, instance_id=None):
r = self._runtime
with r._lock:
if not self._instance_ok(instance_id):
return self._error('UNKNOWN_INSTANCE', request_id)
cap = r._metadata['capabilities'].get(capability_id) if isinstance(capability_id, str) else None
if cap is None or not self._visible(cap):
return self._error('UNKNOWN_CAPABILITY', request_id)
if not isinstance(request_id, str) or not request_id or not self._validate(cap['input_schema'], arguments):
return self._error('INVALID_ARGUMENT', request_id)
digest = _p702cv_json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False)
key = (self._principal_id, request_id)
if key in r._requests:
old_digest, old_result = r._requests[key]
return _p702cv_copy.deepcopy(old_result) if old_digest == digest else self._error('REQUEST_CONFLICT', request_id)
s = _p702cv_copy.deepcopy(r._state)
result = dict(arguments)
if capability_id.startswith('simulation.'):
try:
result = r.step(**arguments) if capability_id == 'simulation.step' else r.set_boundary(**arguments)
except (ValueError, OverflowError, ZeroDivisionError):
return self._error('INVALID_ARGUMENT', request_id)
else:
if capability_id not in ('power.set', 'scene.set_valve_position') and not s['power.enabled']:
return self._error('PRECONDITION_FAILED', request_id)
if capability_id == 'power.set':
s['power.enabled'] = arguments['enabled']
if not arguments['enabled']:
s['valve.opening'] = 0.0
elif capability_id == 'pressure.set_setpoint':
s['pressure.setpoint_pa'] = arguments['pressure_Pa']
if s['pressure.active_setpoint_pa'] is None:
s['pressure.active_setpoint_pa'] = arguments['pressure_Pa']
elif capability_id == 'control.set_mode':
if arguments['mode'] == 'automatic' and (s['pressure.active_setpoint_pa'] is None or s['pressure.reading_pa'] is None):
return self._error('PRECONDITION_FAILED', request_id)
s['control.mode'] = arguments['mode']
elif capability_id == 'control.set_gain':
s['control.gain_per_pa_s'] = arguments['gain_per_Pa_s']
elif capability_id == 'control.set_ramp_rate':
s['control.ramp_rate_pa_s'] = arguments['rate_Pa_s']
elif capability_id == 'valve.set_opening':
if s['control.mode'] != 'manual':
return self._error('PRECONDITION_FAILED', request_id)
s['valve.opening'] = arguments['opening']
elif capability_id == 'scene.set_valve_position':
if r._scene_adapter is None:
return self._error('UNSUPPORTED', request_id)
s['scene.valve_position'] = arguments['position']
try:
r._scene_adapter(r.instance_id, {'scene.valve_position': arguments['position']})
except Exception:
failed = self._error('DEVICE_ERROR', request_id, 'unknown')
r._requests[key] = (digest, _p702cv_copy.deepcopy(failed))
return failed
r._observe(s)
if not all(v is None or isinstance(v, bool) or not isinstance(v, (int, float)) or _p702cv_number(v) for v in s.values()):
return self._error('INVALID_ARGUMENT', request_id)
r._state = s
r._revision += 1
response = self._envelope(result=result, request_id=request_id)
r._requests[key] = (digest, _p702cv_copy.deepcopy(response))
return response
# BEGIN CHEM-182 VICI EUTA APPEND-ONLY RUNTIME
# Independent namespace: no dependencies on other automation instruments.
import copy as _veuta_copy
import json as _veuta_json
import math as _veuta_math
import threading as _veuta_threading
VICI_EUTA_ASSET_TYPE_ID = 'instrument.vici_euta_2sd6mwe'
VICI_EUTA_PORT_IDS = ('port_common', 'port_1', 'port_2', 'port_3', 'port_4', 'port_5', 'port_6')
def _veuta_number(value):
try:
return type(value) in (int, float) and _veuta_math.isfinite(value)
except (ValueError, OverflowError, TypeError):
return False
def _veuta_obj(properties):
return {'type': 'object', 'properties': properties, 'required': list(properties), 'additionalProperties': False}
def _veuta_nullable(schema):
return {'anyOf': [schema, {'type': 'null'}]}
def export_vici_euta_contract_metadata():
"""Return type metadata only; host-only events are separated from agent APIs."""
position = {'type': 'integer', 'minimum': 1, 'maximum': 6, 'x-unit': '1'}
time = {'type': 'number', 'minimum': 0, 'x-unit': 's'}
angle = {'type': 'number', 'minimum': 0, 'maximum': 5 * _veuta_math.pi / 3, 'x-unit': 'rad'}
selected_port = _veuta_nullable({'type': 'string', 'enum': list(VICI_EUTA_PORT_IDS[1:])})
connections = {'type': 'array', 'minItems': 0, 'maxItems': 1,
'items': {'type': 'array', 'minItems': 2, 'maxItems': 2,
'items': {'type': 'string', 'enum': list(VICI_EUTA_PORT_IDS)}}}
flag = {'type': 'boolean'}
definitions = {
'valve.target_position': (_veuta_nullable(position), '1', 'setpoint', ['actuator'], 'valve.select_position', 'position'),
'valve.position': (_veuta_nullable(position), '1', 'derived', ['rotor'], None, None),
'valve.in_position': (flag, '1', 'derived', ['actuator', 'rotor'], None, None),
'valve.switching_time_s': ({'type': 'null'}, 's', 'derived', ['actuator'], None, None),
'route.connected_port_id': (selected_port, '1', 'derived', ['valve_body'], None, None),
'route.connections': (connections, '1', 'derived', ['valve_body'], None, None),
'scene.rotor_angle_rad': (angle, 'rad', 'scene', ['rotor'], None, None),
'scene.sync_status': ({'type': 'string', 'enum': ['unbound', 'synced']}, '1', 'scene', ['rotor'], None, None),
}
slots = {}
for key, (schema, unit, origin, components, cap, arg) in definitions.items():
slots[key] = {'value_schema': schema, 'unit': unit, 'origin': origin, 'visibility': 'agent',
'access': 'read_write' if cap else 'read_only', 'component_ids': components,
'write_via': {'capability_id': cap, 'argument': arg, 'fixed_arguments': {}} if cap else None,
'reference_conditions': 'Rotor local Z; theta=(position-1)*pi/3; zero is synthetic initial visual pose' if key == 'scene.rotor_angle_rad' else None,
'sampling': {'mode': 'static' if key == 'valve.switching_time_s' else 'instant', 'time_domain': 'none' if key == 'valve.switching_time_s' else 'simulation', 'window': None}}
select_effects = ['valve.target_position', 'valve.position', 'valve.in_position', 'route.connected_port_id', 'route.connections']
arrive_effects = ['valve.position', 'valve.in_position', 'route.connected_port_id', 'route.connections', 'scene.rotor_angle_rad', 'scene.sync_status']
select_result = ['valve.target_position', 'valve.in_position', 'route.connected_port_id']
arrive_result = ['valve.position', 'valve.in_position', 'route.connected_port_id', 'route.connections', 'scene.rotor_angle_rad', 'scene.sync_status']
def cap(inputs, outputs, example, effects, components, visibility, description):
return {'input_schema': _veuta_obj(inputs), 'output_schema': _veuta_obj(outputs),
'example_arguments': example, 'state_effects': effects, 'component_ids': components,
'visibility': visibility, 'description_zh': description, 'availability': 'implemented'}
capabilities = {'valve.select_position': cap({'position': position}, {k: slots[k]['value_schema'] for k in select_result},
{'position': 3}, select_effects, ['actuator', 'rotor', 'valve_body'], 'agent',
'仅写入6位选择目标，立即撤销到位并断开抽象气路；成功不是切换完成。')}
host_caps = {
'host.arrive': cap({'position': position, 'world_time_s': time}, {k: slots[k]['value_schema'] for k in arrive_result},
{'position': 3, 'world_time_s': 1.0}, arrive_effects, ['actuator', 'rotor', 'valve_body'], 'debug',
'可信宿主显式确认目标到位并提交转子姿态；只建立公共口与选中端口的无向连接。'),
'host.set_time': cap({'world_time_s': time}, {'world_time_s': time}, {'world_time_s': 1.0}, [], ['actuator'], 'debug',
'接收宿主共同世界时钟；不自动推断到位、不生成切换持续时间。')}
return {'asset_type_id': VICI_EUTA_ASSET_TYPE_ID, 'asset_version': '1.0.2', 'catalog_id': 'CHEM-182',
'adapter': 'basic40_runtime_automation.ViciEutaValveRuntime', 'state_slots': slots,
'capabilities': capabilities, 'host_capabilities': host_caps,
'configuration': {'position_count': 6, 'thermal_standoff_length_m': 0.0508,
'fitting_nominal_outer_diameter_m': 0.003175, 'bore_diameter_m': 0.001,
'gas_pressure_rating_Pa': 400 * 6894.757293168, 'maximum_temperature_K': 473.15,
'drive_voltage_V': 24, 'serial_interfaces': ['RS232', 'RS485'],
'switching_time_s': None, 'dead_volume_m3': None, 'residual_fraction': None,
'cross_contamination_fraction': None, 'whole_instrument_envelope_m': None,
'whole_instrument_mass_kg': None,
'unknown_evidence': '未取得本EUTA配置的当前切换时间、死体积、残留、交叉污染及整机实测包络质量；不使用旧EMT时序'},
'scene_binding': {'callback': 'scene_adapter(instance_id, {"scene.rotor_angle_rad": angle_rad})',
'object': 'vici_euta__rotor_joint', 'axis': 'local_z', 'mapping': '(position-1)*pi/3'},
'limitations': [
'仅实现6位选择的离散拓扑；没有流量、压降、死体积、冲洗、残留、交叉污染或切换瞬态求解。',
'到位为可信宿主事件生成的derived状态，不是硬件传感器读数。实际切换时间未知且保持null。',
'初始无已知阀位与连接；转子零角只是合成场景初始姿态，不代表硬件归零。',
'转动过程中抽象气路断开是仿真安全规则，未声称厂家的真实过渡流道具有同样行为。',
'没有宿主到位事件时，即使世界时间前进也不自动完成；没有时长、加速度、扭矩和中间角度模型。',
'scene_adapter未绑定时仅更新场景目标数值并报告unbound；绑定成功为synced，需另做实际模型求值验证。',
'场景回调失败时内部状态和时钟不变，外部场景副作用unknown；同请求重放不会再次调用回调。',
'公共口与6个端口为无向气路连接；实例间气路、库存和守恒由宿主管理。',
'没有硬件或机器人驱动；宿主事件不会公开到agent describe/invoke。Python对象及文件权限须由宿主另外隔离。',
'去重仅单实例进程内内存有效；没有跨重启恰好一次保证。']}
class ViciEutaValveRuntime:
"""Trusted host owns an independent six-position valve instance.
Agent-facing methods are describe/read/invoke/write. host_arrive and
host_set_time are trusted host hooks, not user-callable capabilities.
State changes are discrete and need no invented physical switching time.
"""
def __init__(self, instance_id, *, scene_adapter=None, initial_world_time_s=0.0):
if not isinstance(instance_id, str) or not instance_id.strip():
raise ValueError('A nonempty instance_id is required')
if not _veuta_number(initial_world_time_s) or initial_world_time_s < 0:
raise ValueError('Initial host clock must be finite and nonnegative')
if scene_adapter is not None and not callable(scene_adapter):
raise ValueError('scene_adapter must be callable or None')
self.instance_id = instance_id
self._scene_adapter = scene_adapter
self._metadata = export_vici_euta_contract_metadata()
self._state = {'valve.target_position': None, 'valve.position': None, 'valve.in_position': False,
'valve.switching_time_s': None, 'route.connected_port_id': None, 'route.connections': [],
'scene.rotor_angle_rad': 0.0, 'scene.sync_status': 'unbound'}
self._time_s = float(initial_world_time_s)
self._revision = 0
self._requests = {}
self._lock = _veuta_threading.RLock()
def _envelope(self, *, request_id=None, status='succeeded', result=None, observations=None, error=None):
return {'protocol_version': '1.0.0', 'instance_id': self.instance_id,
'request_id': request_id if isinstance(request_id, str) else None,
'operation_id': None, 'status': status, 'state_revision': self._revision,
'clock': {'domain': 'simulation', 'time_s': self._time_s},
'result': result if result is not None else {},
'observations': observations if observations is not None else {}, 'error': error}
def _error(self, code, request_id=None, *, side_effects='none'):
messages = {'UNKNOWN_INSTANCE': 'Instance unavailable', 'UNKNOWN_CAPABILITY': 'Capability unavailable',
'INVALID_ARGUMENT': 'Arguments do not match the supported schema',
'ACCESS_DENIED': 'State unavailable or not writable',
'PRECONDITION_FAILED': 'Operation preconditions are not satisfied',
'BUSY': 'A target is pending host arrival confirmation',
'REQUEST_CONFLICT': 'Request ID was previously used with another payload',
'DEVICE_ERROR': 'Scene callback failed; external state is uncertain'}
return self._envelope(request_id=request_id, status='failed' if code == 'DEVICE_ERROR' else 'rejected',
error={'code': code, 'message': messages[code], 'retryable': False,
'side_effects': side_effects})
def _instance_ok(self, instance_id):
return instance_id is None or isinstance(instance_id, str) and instance_id == self.instance_id
@staticmethod
def _validate(schema, value):
if 'anyOf' in schema:
return any(ViciEutaValveRuntime._validate(s, value) for s in schema['anyOf'])
kind = schema['type']
if kind == 'null':
return value is None
if kind == 'integer':
return type(value) is int and ('minimum' not in schema or value >= schema['minimum']) and ('maximum' not in schema or value <= schema['maximum'])
if kind == 'number':
return _veuta_number(value) and ('minimum' not in schema or value >= schema['minimum']) and ('maximum' not in schema or value <= schema['maximum'])
if kind == 'boolean':
return type(value) is bool
if kind == 'string':
return isinstance(value, str) and ('enum' not in schema or value in schema['enum'])
if kind == 'array':
return isinstance(value, list) and len(value) >= schema.get('minItems', 0) and len(value) <= schema.get('maxItems', len(value)) and all(ViciEutaValveRuntime._validate(schema['items'], v) for v in value)
if kind == 'object':
return isinstance(value, dict) and set(value) == set(schema['properties']) and all(ViciEutaValveRuntime._validate(s, value[k]) for k, s in schema['properties'].items())
return False
def describe(self, *, asset_type_id=None, instance_id=None):
with self._lock:
if asset_type_id is not None and instance_id is not None:
return self._error('INVALID_ARGUMENT')
if not self._instance_ok(instance_id) or asset_type_id is not None and asset_type_id != VICI_EUTA_ASSET_TYPE_ID:
return self._error('UNKNOWN_INSTANCE')
result = _veuta_copy.deepcopy(self._metadata)
result.pop('host_capabilities')
return result
def read(self, *, state_ids=None, instance_id=None):
with self._lock:
if not self._instance_ok(instance_id):
return self._error('UNKNOWN_INSTANCE')
ids = list(self._metadata['state_slots']) if state_ids is None else state_ids
if not isinstance(ids, list) or any(not isinstance(key, str) for key in ids):
return self._error('INVALID_ARGUMENT')
if any(key not in self._metadata['state_slots'] for key in ids):
return self._error('ACCESS_DENIED')
observations = {}
for key in ids:
value = self._state[key]
reason = 'unknown_configuration_specification' if key == 'valve.switching_time_s' else 'no_confirmed_position_or_connection'
observations[key] = {'value': _veuta_copy.deepcopy(value), 'unit': self._metadata['state_slots'][key]['unit'],
'quality': 'unavailable' if value is None else 'estimated' if key in ('valve.position', 'valve.in_position') else 'valid',
'sample_time_s': self._time_s, 'sample_window_s': None,
'unavailable_reason': reason if value is None else None}
return self._envelope(observations=observations)
def write(self, *, state_id, value, request_id, instance_id=None):
with self._lock:
if not self._instance_ok(instance_id):
return self._error('UNKNOWN_INSTANCE', request_id)
slot = self._metadata['state_slots'].get(state_id) if isinstance(state_id, str) else None
if slot is None or slot['write_via'] is None:
return self._error('ACCESS_DENIED', request_id)
route = slot['write_via']
return self.invoke(capability_id=route['capability_id'], arguments={route['argument']: value}, request_id=request_id, instance_id=instance_id)
def invoke(self, *, capability_id, arguments, request_id, instance_id=None):
return self._invoke(capability_id=capability_id, arguments=arguments, request_id=request_id, instance_id=instance_id, host=False)
def host_arrive(self, *, position, world_time_s, request_id):
return self._invoke(capability_id='host.arrive', arguments={'position': position, 'world_time_s': world_time_s}, request_id=request_id, host=True)
def host_set_time(self, *, world_time_s, request_id):
return self._invoke(capability_id='host.set_time', arguments={'world_time_s': world_time_s}, request_id=request_id, host=True)
def debug_snapshot(self):
"""Trusted test/host view, never a discoverable agent capability."""
with self._lock:
return {'instance_id': self.instance_id, 'state_revision': self._revision,
'world_time_s': self._time_s, 'state': _veuta_copy.deepcopy(self._state)}
def _invoke(self, *, capability_id, arguments, request_id, host, instance_id=None):
with self._lock:
if not self._instance_ok(instance_id):
return self._error('UNKNOWN_INSTANCE', request_id)
capabilities = self._metadata['host_capabilities'] if host else self._metadata['capabilities']
cap = capabilities.get(capability_id) if isinstance(capability_id, str) else None
if cap is None:
return self._error('UNKNOWN_CAPABILITY', request_id)
if not isinstance(request_id, str) or not request_id.strip() or not self._validate(cap['input_schema'], arguments):
return self._error('INVALID_ARGUMENT', request_id)
digest = _veuta_json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False)
key = ('host' if host else 'agent', request_id)
if key in self._requests:
prior_digest, prior_result = self._requests[key]
return _veuta_copy.deepcopy(prior_result) if prior_digest == digest else self._error('REQUEST_CONFLICT', request_id)
state = _veuta_copy.deepcopy(self._state)
time_s = self._time_s
if host and arguments['world_time_s'] < self._time_s:
return self._error('PRECONDITION_FAILED', request_id)
if capability_id == 'valve.select_position':
position = arguments['position']
if state['valve.target_position'] is not None and not state['valve.in_position']:
return self._error('BUSY', request_id)
if state['valve.in_position'] and state['valve.position'] == position:
return self._error('PRECONDITION_FAILED', request_id)
state.update({'valve.target_position': position, 'valve.position': None, 'valve.in_position': False,
'route.connected_port_id': None, 'route.connections': []})
result = {k: state[k] for k in ('valve.target_position', 'valve.in_position', 'route.connected_port_id')}
elif capability_id == 'host.arrive':
position = arguments['position']
if state['valve.target_position'] != position or state['valve.in_position']:
return self._error('PRECONDITION_FAILED', request_id)
angle = (position - 1) * _veuta_math.pi / 3
if self._scene_adapter is not None:
try:
self._scene_adapter(self.instance_id, {'scene.rotor_angle_rad': angle})
except Exception:
failure = self._error('DEVICE_ERROR', request_id, side_effects='unknown')
self._requests[key] = (digest, _veuta_copy.deepcopy(failure))
return failure
state.update({'valve.position': position, 'valve.in_position': True,
'route.connected_port_id': 'port_%d' % position,
'route.connections': [['port_common', 'port_%d' % position]],
'scene.rotor_angle_rad': angle,
'scene.sync_status': 'synced' if self._scene_adapter is not None else 'unbound'})
time_s = float(arguments['world_time_s'])
result = {k: state[k] for k in ('valve.position', 'valve.in_position', 'route.connected_port_id', 'route.connections', 'scene.rotor_angle_rad', 'scene.sync_status')}
else:
if arguments['world_time_s'] == self._time_s:
return self._error('PRECONDITION_FAILED', request_id)
time_s = float(arguments['world_time_s'])
result = {'world_time_s': time_s}
self._state = state
self._time_s = time_s
self._revision += 1
response = self._envelope(request_id=request_id, result=_veuta_copy.deepcopy(result))
self._requests[key] = (digest, _veuta_copy.deepcopy(response))
return response
# END CHEM-182 VICI EUTA APPEND-ONLY RUNTIME
# BEGIN CHEM-179 ZIATH DP5 MIRAGE APPEND-ONLY RUNTIME
"""CHEM-179 synthetic barcode-observation adapter, no optical decoder/hardware.
The trusted host owns scenarios, principals, callbacks, and the common clock.
Only hand ZiathDP5Session to an agent. Python access control is not a sandbox.
"""
import copy as _dp5_copy
import csv as _dp5_csv
import io as _dp5_io
import json as _dp5_json
import math as _dp5_math
import threading as _dp5_threading
ZIATH_DP5_TYPE = 'instrument.ziath_dp5_mirage_2023'
ZIATH_DP5_FORMATS = (24, 48, 96, 240)
ZIATH_DP5_SCAN_S = 2.0
def _dp5_number(value):
try:
return type(value) in (int, float) and _dp5_math.isfinite(value)
except (TypeError, OverflowError):
return False
def _dp5_obj(properties):
return {'type': 'object', 'properties': properties, 'required': list(properties), 'additionalProperties': False}
def _dp5_num(unit, low=0, high=None):
value = {'type': 'number', 'minimum': low, 'x-unit': unit}
if high is not None:
value['maximum'] = high
return value
def _dp5_nullable(schema):
return {'anyOf': [schema, {'type': 'null'}]}
def _dp5_slot(schema, unit, origin, visibility='agent', via=None):
return {'value_schema': schema, 'unit': unit, 'origin': origin, 'visibility': visibility,
'access': 'read_write' if via else 'read_only', 'reference_conditions': None,
'write_via': {'capability_id': via[0], 'parameter': via[1], 'fixed_arguments': {}} if via else None,
'sampling': {'mode': 'instant', 'time_domain': 'simulation', 'window': None}}
_DP5_STRING = {'type': 'string'}
_DP5_LIST = {'type': 'array', 'items': _DP5_STRING}
_DP5_FORMAT = {'type': 'integer', 'enum': list(ZIATH_DP5_FORMATS), 'x-unit': '1'}
_DP5_EXPORT = {'type': 'string', 'enum': ['json', 'csv']}
_DP5_SCAN_STATUS = {'type': 'string', 'enum': ['idle', 'running', 'succeeded', 'cancelled']}
_DP5_ROW = _dp5_obj({'well_id': _DP5_STRING, 'tube_id': _dp5_nullable(_DP5_STRING),
'status': {'type': 'string', 'enum': ['read', 'missing', 'matched', 'mismatch', 'unexpected']},
'expected_tube_id': _dp5_nullable(_DP5_STRING)})
_DP5_RESULT = _dp5_obj({'rack_id': _DP5_STRING, 'rack_format': _DP5_FORMAT,
'mapping': {'type': 'array', 'items': _DP5_ROW}, 'missing_wells': _DP5_LIST,
'mismatch_wells': _DP5_LIST, 'unexpected_wells': _DP5_LIST, 'duplicate_tube_ids': _DP5_LIST,
'identity_matching': {'type': 'boolean'}, 'completed_time_s': _dp5_num('s'),
'quality': {'type': 'string', 'const': 'estimated'}})
_DP5_PRIVATE_PAIRS = {'type': 'array', 'items': _dp5_obj({'well_id': _DP5_STRING, 'tube_id': _dp5_nullable(_DP5_STRING)})}
_DP5_SLOTS = {
'power.enabled': _dp5_slot({'type': 'boolean'}, '1', 'setpoint', via=('power.set', 'enabled')),
'configuration.rack_format': _dp5_slot(_DP5_FORMAT, '1', 'setpoint'),
'configuration.identity_matching': _dp5_slot({'type': 'boolean'}, '1', 'setpoint'),
'configuration.export_format': _dp5_slot(_DP5_EXPORT, '1', 'setpoint'),
'rack.loaded': _dp5_slot({'type': 'boolean'}, '1', 'scene'),
'rack.rack_id': _dp5_slot(_dp5_nullable(_DP5_STRING), '1', 'scene'),
'rack.well_ids': _dp5_slot(_DP5_LIST, '1', 'scene'),
'rack.attachment_constraint_id': _dp5_slot(_dp5_nullable(_DP5_STRING), '1', 'scene'),
'scene.rack_lift_m': _dp5_slot(_dp5_num('m', 0, 0.10), 'm', 'scene', via=('scene.set_rack_lift', 'lift_m')),
'scene.rack_format': _dp5_slot(_DP5_FORMAT, '1', 'scene'),
'acquisition.status': _dp5_slot(_DP5_SCAN_STATUS, '1', 'derived'),
'acquisition.elapsed_s': _dp5_slot(_dp5_num('s', 0, 2), 's', 'derived'),
'acquisition.progress': _dp5_slot(_dp5_num('1', 0, 1), '1', 'derived'),
'results.data': _dp5_slot(_dp5_nullable(_DP5_RESULT), '1', 'derived'),
'truth.visible_barcodes': _dp5_slot(_DP5_PRIVATE_PAIRS, '1', 'process_truth', 'debug'),
'truth.task_manifest': _dp5_slot(_DP5_PRIVATE_PAIRS, '1', 'process_truth', 'debug'),
}
_DP5_OPERATION = _dp5_obj({'operation_id': _DP5_STRING, 'status': _DP5_SCAN_STATUS,
'elapsed_s': _dp5_num('s', 0, 2), 'progress': _dp5_num('1', 0, 1),
'results_available': {'type': 'boolean'}})
_DP5_COMPONENTS = {
'power.set': ['power_data_panel', 'status_indicator'],
'configuration.set': ['rack_carriage'],
'acquisition.start': ['optical_module', 'scan_window'],
'acquisition.poll': ['optical_module', 'scan_window'],
'acquisition.cancel': ['optical_module', 'scan_window'],
'results.export': ['power_data_panel'],
'scene.set_rack_lift': ['rack_carriage'],
}
_DP5_INVALIDATE = ['acquisition.status', 'acquisition.elapsed_s', 'acquisition.progress', 'results.data']
_DP5_LIMITATIONS = [
'仅处理可信宿主提供的合成可见条码观测，不读取真实图像，不实现像素识别、遮挡、霜雾或误识率模型。',
'2.0 s为表中约2 s的固定仿真近似；不是实测扫描时间分布。完成时一次公布整架结果，取消保留时间进度但不发布部分管ID。',
'24/48/96/240为支持容量；每个孔位ID由宿主明确提供，未知行列排布未内置为厂家参数。空管与漏读不能由null条码区分，均标missing。',
'身份匹配仅比对宿主任务清单与条码观测；不确认真实样品身份或化学组成，无化学过程。',
'外部管架抬升0..0.10 m是假设场景行程，不是Mirage自带电机；机械同步依赖host scene_adapter的True确认。',
'attach/release仅登记宿主约束回调确认的附着事件；无接触求解或机器人抓取，robot与hardware层absent。',
'请求去重只在当前宿主内存有效；API可见性过滤不是Python、共享文件系统或进程安全隔离。',
'导出返回内存中的JSON/CSV文本，不写文件、不发送网络；CSV单元格仅承载合成观测数据。',
]
def export_ziath_dp5_contract_metadata():
slots = _dp5_copy.deepcopy(_DP5_SLOTS)
for sid, slot in slots.items():
slot['read_binding'] = 'ZiathDP5Session.read(instance_id=..., state_ids=[%r])' % sid
slots['scene.rack_lift_m']['reference_conditions'] = 'Rack carriage local +Z relative to seated rack; external lift assumption 0..0.10 m'
specs = {
'power.set': ({'enabled': {'type': 'boolean'}}, _dp5_obj({'enabled': {'type': 'boolean'}}), {'enabled': True}, ['power.enabled', 'acquisition.status'], 'device_command', '设置仿真供电与显示；断电取消正在扫描的任务并保留已用时间。'),
'configuration.set': ({'rack_format': _DP5_FORMAT, 'identity_matching': {'type': 'boolean'}, 'export_format': _DP5_EXPORT}, _dp5_obj({'rack_format': _DP5_FORMAT, 'identity_matching': {'type': 'boolean'}, 'export_format': _DP5_EXPORT}), {'rack_format': 96, 'identity_matching': True, 'export_format': 'json'}, ['configuration.rack_format', 'configuration.identity_matching', 'configuration.export_format', 'scene.rack_format'] + _DP5_INVALIDATE, 'configuration', '设置容量、身份匹配与默认导出格式；清除上次结果。'),
'acquisition.start': ({}, _DP5_OPERATION, {}, _DP5_INVALIDATE, 'device_command', '启动约2 s的合成整架读取；accepted不含管ID。'),
'acquisition.poll': ({'operation_id': _DP5_STRING}, _DP5_OPERATION, {'operation_id': 'scan_demo_1'}, [], 'query', '读取本身份发起的操作进度；不推进时间且不返回管ID。'),
'acquisition.cancel': ({'operation_id': _DP5_STRING}, _DP5_OPERATION, {'operation_id': 'scan_demo_1'}, ['acquisition.status'], 'device_command', '取消本身份的运行操作；保留已经消耗的时间与进度，不发布未完成结果。'),
'results.export': ({'format': _DP5_EXPORT}, _dp5_obj({'format': _DP5_EXPORT, 'media_type': _DP5_STRING, 'content': _DP5_STRING, 'row_count': {'type': 'integer', 'minimum': 0, 'maximum': 240, 'x-unit': '1'}}), {'format': 'json'}, [], 'query', '将已完成的合成管ID-孔位映射、漏读和不匹配状态导出为内存文本。'),
'scene.set_rack_lift': ({'lift_m': _dp5_num('m', 0, .10)}, _dp5_obj({'lift_m': _dp5_num('m', 0, .10)}), {'lift_m': .05}, ['scene.rack_lift_m'], 'configuration', '由宿主场景回调移动外部管架；不表示仪器内置致动或机器人操作。'),
}
prereq = {
'power.set': ['scene_adapter已绑定并返回True确认。'],
'configuration.set': ['已上电；没有正在扫描的操作；scene_adapter返回True确认；格式与已装管架一致。'],
'acquisition.start': ['已上电；已装管架；无正在扫描任务；管架抬升为0；格式匹配。'],
'acquisition.poll': ['operation_id属于当前实例与宿主登记的调用者。'],
'acquisition.cancel': ['operation_id属于当前实例与宿主登记的调用者。'],
'results.export': ['本次扫描已完成且结果可用。'],
'scene.set_rack_lift': ['已装管架；没有正在扫描的操作；scene_adapter已绑定并返回True确认。'],
}
caps = {}
for cid, (props, output, example, effects, kind, description) in specs.items():
scene = cid in ('power.set', 'configuration.set', 'scene.set_rack_lift')
observed = {'power.set': ['power.enabled'], 'configuration.set': ['configuration.rack_format', 'configuration.identity_matching', 'configuration.export_format'],
'acquisition.start': ['acquisition.status', 'acquisition.elapsed_s', 'acquisition.progress'],
'acquisition.poll': ['acquisition.status', 'acquisition.elapsed_s', 'acquisition.progress'],
'acquisition.cancel': ['acquisition.status', 'acquisition.elapsed_s', 'acquisition.progress'],
'results.export': ['results.data'], 'scene.set_rack_lift': ['scene.rack_lift_m']}[cid]
entries = [{'state_id': s, 'timing': 'immediate', 'description_zh': '同步更新此声明状态；拒绝时不改变内部状态。'} for s in effects]
if cid == 'acquisition.start':
entries += [{'state_id': s, 'timing': 'on_step', 'description_zh': '仅由宿主共同时间推进，约2 s完成时发布合成结果。'} for s in _DP5_INVALIDATE]
caps[cid] = {'name_zh': description, 'description_zh': description, 'kind': kind, 'visibility': 'agent', 'availability': 'implemented',
'component_ids': _DP5_COMPONENTS[cid], 'input_schema': _dp5_obj(_dp5_copy.deepcopy(props)), 'output_schema': _dp5_copy.deepcopy(output),
'state_effects': entries, 'observes': observed, 'example_arguments': [_dp5_copy.deepcopy(example)], 'preconditions_zh': prereq[cid],
'binding': 'basic40_runtime_automation.ZiathDP5Session.invoke(instance_id=..., capability_id=%r, arguments=..., request_id=...)' % cid,
'implementation': {'process': 'implemented' if cid != 'scene.set_rack_lift' else 'not_applicable', 'scene': 'implemented' if scene else 'not_applicable', 'robot': 'absent', 'hardware': 'absent', 'host': 'implemented'},
'model_effects': {'mode': 'host_required' if scene else 'none', 'binding_ids': [], 'description_zh': 'scene_adapter(instance_id,targets)须返回True；缺失返回unsupported；外部异常不提交内部状态但外部副作用可能未知。' if scene else '只改变数据与任务状态，无新的可见机械动作。'},
'execution_notes': {'mode': 'asynchronous' if cid == 'acquisition.start' else 'synchronous', 'time_domain': 'simulation', 'completion_zh': '宿主累计扫描时间达到2.0 s并发布整架结果。' if cid == 'acquisition.start' else '返回succeeded表示本调用完成。', 'cancellable': cid == 'acquisition.start', 'partial_failure_zh': '取消保留elapsed_s/progress；未完成扫描没有可导出的部分管ID。', 'retry_zh': '同一request_id与参数返回缓存响应，参数冲突拒绝；当前进程内存有效。'},
'errors': [{'code': code, 'description_zh': meaning, 'side_effects': side} for code, meaning, side in [
('INVALID_ARGUMENT', '参数类型、范围或多余字段错误。', 'none'), ('UNKNOWN_INSTANCE', '实例不存在或不在当前身份范围。', 'none'),
('UNKNOWN_CAPABILITY', '能力不存在或不对当前身份公开。', 'none'), ('PRECONDITION_FAILED', '当前供电、管架或结果状态不允许操作。', 'none'),
('BUSY', '扫描资源正在使用。', 'none'), ('REQUEST_CONFLICT', '同一请求ID被用于不同参数。', 'none'),
('UNSUPPORTED', '需要的场景回调尚未绑定。', 'none'), ('DEVICE_ERROR', '外部回调未确认；内部状态未提交，外部可能已部分改变。', 'unknown'),
('UNKNOWN_OPERATION', '操作不存在或不属于当前实例和调用者。', 'none')]]}
return {'asset_type_id': ZIATH_DP5_TYPE, 'asset_version': '1.0.1', 'catalog_id': 'CHEM-179', 'state_slots': slots, 'capabilities': caps,
'parameters': {'scan_time_s': {'value': 2.0, 'unit': 's', 'evidence': 'catalog_approximation', 'note_zh': '约2 s规格用于固定时长仿真近似。'},
'supported_rack_capacities': {'value': list(ZIATH_DP5_FORMATS), 'unit': '1', 'evidence': 'catalog'},
'rack_lift_limit_m': {'value': .10, 'unit': 'm', 'evidence': 'assumed'},
'barcode_pixel_size_m': {'value': None, 'unit': 'm', 'evidence': 'unknown'}, 'misidentification_rate': {'value': None, 'unit': '1', 'evidence': 'unknown'},
'occlusion_limit': {'value': None, 'unit': '1', 'evidence': 'unknown'}, 'frost_response': {'value': None, 'unit': '1', 'evidence': 'unknown'}},
'host_api': {
'create_instance': {'entrypoint': 'ZiathDP5Runtime.create_instance(instance_id, scene_adapter=None)', 'description_zh': '独立状态、请求缓存和场景回调；初始未上电。'},
'register_principal': {'entrypoint': 'ZiathDP5Runtime.register_principal(principal_id, visibility, instance_ids=None)', 'description_zh': '身份与可见性只能由宿主登记。'},
'host_load_rack': {'entrypoint': 'ZiathDP5Runtime.host_load_rack(instance_id, rack_id=..., rack_format=..., well_ids=..., visible_barcodes=..., task_manifest=...)', 'description_zh': '宿主显式传入容量个唯一孔位及其合成可见条码/任务清单；禁止扫描中替换；仅调试会话可读预扫描输入。'},
'host_step': {'entrypoint': 'ZiathDP5Runtime.host_step(dt_s, world_time_s=...)', 'description_zh': '正有限dt与单调共同时间一致；推进此宿主全部实例，完成后一次发布整架结果。'},
'host_attach': {'entrypoint': 'ZiathDP5Runtime.host_attach(instance_id, constraint_id=..., attachment_adapter=...)', 'event': 'attach', 'description_zh': '回调(instance_id,{event:attach,rack_id:...,constraint_id:...})须返回True；只登记宿主已实现约束，不实现抓取。'},
'host_release': {'entrypoint': 'ZiathDP5Runtime.host_release(instance_id, attachment_adapter=...)', 'event': 'release', 'description_zh': '回调须确认释放现存constraint_id；保留管架装载和位置，不假设容器回原处。'}},
'limitations': list(_DP5_LIMITATIONS), 'output_schema_scope': 'capability output_schema validates response.result; all examples contain synthetic data only'}
class ZiathDP5Runtime:
"""Trusted multi-instance host. No hardware entrypoints are provided."""
def __init__(self):
self.time_s = 0.0
self._instances = {}
self._principals = {}
self._requests = {}
self._operations = {}
self._next_operation = 1
self._lock = _dp5_threading.RLock()
def create_instance(self, instance_id, scene_adapter=None):
with self._lock:
if not isinstance(instance_id, str) or not instance_id or instance_id in self._instances or (scene_adapter is not None and not callable(scene_adapter)):
raise ValueError('Unique instance ID and callable optional adapter required')
state = {'power.enabled': False, 'configuration.rack_format': 96, 'configuration.identity_matching': True, 'configuration.export_format': 'json',
'rack.loaded': False, 'rack.rack_id': None, 'rack.well_ids': [], 'rack.attachment_constraint_id': None, 'scene.rack_lift_m': 0.0,
'scene.rack_format': 96, 'acquisition.status': 'idle', 'acquisition.elapsed_s': 0.0, 'acquisition.progress': 0.0, 'results.data': None,
'truth.visible_barcodes': [], 'truth.task_manifest': []}
self._instances[instance_id] = {'state': state, 'revision': 0, 'adapter': scene_adapter, 'rack_format': None, 'active_operation': None}
def register_principal(self, principal_id, *, visibility, instance_ids=None):
with self._lock:
if not isinstance(principal_id, str) or not principal_id or principal_id in self._principals or visibility not in ('agent', 'debug', 'evaluator'):
raise ValueError('Host-assigned unique identity with valid visibility required')
if instance_ids is not None and (not isinstance(instance_ids, (list, tuple, set, frozenset)) or any(k not in self._instances for k in instance_ids)):
raise ValueError('Invalid instance scope')
self._principals[principal_id] = (visibility, None if instance_ids is None else frozenset(instance_ids))
def session(self, principal_id):
if principal_id not in self._principals:
raise ValueError('Host registration required')
return ZiathDP5Session(self, principal_id)
def _get(self, instance_id, principal_id=None):
if not isinstance(instance_id, str) or instance_id not in self._instances:
return None
if principal_id is not None:
scope = self._principals[principal_id][1]
if scope is not None and instance_id not in scope:
return None
return self._instances[instance_id]
@staticmethod
def _invalidate(item):
item['state'].update({'acquisition.status': 'idle', 'acquisition.elapsed_s': 0.0, 'acquisition.progress': 0.0, 'results.data': None})
item['active_operation'] = None
def host_load_rack(self, instance_id, *, rack_id, rack_format, well_ids, visible_barcodes, task_manifest):
with self._lock:
item = self._get(instance_id)
if item is None or type(rack_format) is not int or rack_format not in ZIATH_DP5_FORMATS or not isinstance(rack_id, str) or not rack_id:
raise ValueError('Invalid rack identity or format')
if not isinstance(well_ids, list) or len(well_ids) != rack_format or any(not isinstance(w, str) or not w for w in well_ids) or len(set(well_ids)) != rack_format:
raise ValueError('Exactly capacity distinct explicit well IDs required')
for mapping in (visible_barcodes, task_manifest):
if not isinstance(mapping, dict) or any(k not in well_ids or not isinstance(v, str) or not v for k, v in mapping.items()):
raise ValueError('Mappings require known wells and nonempty IDs; omitted observations are missing reads')
if item['state']['acquisition.status'] == 'running' or item['state']['rack.attachment_constraint_id'] is not None:
raise ValueError('Cannot replace a scanning or attached rack')
if rack_format != item['state']['configuration.rack_format']:
raise ValueError('Configure matching capacity before rack load')
state = item['state']
state.update({'rack.loaded': True, 'rack.rack_id': rack_id, 'rack.well_ids': list(well_ids),
'truth.visible_barcodes': [{'well_id': w, 'tube_id': visible_barcodes.get(w)} for w in well_ids],
'truth.task_manifest': [{'well_id': w, 'tube_id': task_manifest.get(w)} for w in well_ids]})
item['rack_format'] = rack_format
self._invalidate(item)
item['revision'] += 1
def host_attach(self, instance_id, *, constraint_id, attachment_adapter):
with self._lock:
item = self._get(instance_id)
if item is None or not isinstance(constraint_id, str) or not constraint_id or not callable(attachment_adapter):
raise ValueError('Valid instance, constraint ID and host callback required')
state = item['state']
if not state['rack.loaded'] or state['rack.attachment_constraint_id'] is not None or state['acquisition.status'] == 'running':
raise ValueError('Rack must be loaded, unattached, and idle')
event = {'event': 'attach', 'rack_id': state['rack.rack_id'], 'constraint_id': constraint_id}
if attachment_adapter(instance_id, _dp5_copy.deepcopy(event)) is not True:
raise RuntimeError('Attachment not confirmed; external effect may be unknown')
state['rack.attachment_constraint_id'] = constraint_id
item['revision'] += 1
return event
def host_release(self, instance_id, *, attachment_adapter):
with self._lock:
item = self._get(instance_id)
if item is None or not callable(attachment_adapter) or item['state']['rack.attachment_constraint_id'] is None or item['state']['acquisition.status'] == 'running':
raise ValueError('Idle attached rack and host callback required')
event = {'event': 'release', 'rack_id': item['state']['rack.rack_id'], 'constraint_id': item['state']['rack.attachment_constraint_id']}
if attachment_adapter(instance_id, _dp5_copy.deepcopy(event)) is not True:
raise RuntimeError('Release not confirmed; external effect may be unknown')
item['state']['rack.attachment_constraint_id'] = None
item['revision'] += 1
return event
@staticmethod
def _scan_result(item, completed_s):
s = item['state']
observations = {row['well_id']: row['tube_id'] for row in s['truth.visible_barcodes']}
manifest = {row['well_id']: row['tube_id'] for row in s['truth.task_manifest']}
match = s['configuration.identity_matching']
rows, missing, mismatch, unexpected, seen, duplicates = [], [], [], [], set(), set()
for well in s['rack.well_ids']:
code, expected = observations[well], manifest[well] if match else None
status = 'missing' if code is None else 'read'
if code is None:
missing.append(well)
elif match:
if expected is None:
status = 'unexpected'
unexpected.append(well)
elif code == expected:
status = 'matched'
else:
status = 'mismatch'
mismatch.append(well)
if code is not None:
if code in seen:
duplicates.add(code)
seen.add(code)
rows.append({'well_id': well, 'tube_id': code, 'expected_tube_id': expected, 'status': status})
return {'rack_id': s['rack.rack_id'], 'rack_format': item['rack_format'], 'mapping': rows, 'missing_wells': missing,
'mismatch_wells': mismatch, 'unexpected_wells': unexpected, 'duplicate_tube_ids': sorted(duplicates),
'identity_matching': match, 'completed_time_s': completed_s, 'quality': 'estimated'}
def host_step(self, dt_s, *, world_time_s):
with self._lock:
if not _dp5_number(dt_s) or dt_s <= 0 or not _dp5_number(world_time_s) or world_time_s <= self.time_s or not _dp5_math.isclose(world_time_s - self.time_s, dt_s, rel_tol=1e-12, abs_tol=1e-12):
raise ValueError('Positive finite dt must agree with the common monotonic world clock')
if not _dp5_number(self.time_s + dt_s):
raise ValueError('Clock overflow')
for item in self._instances.values():
if item['state']['acquisition.status'] != 'running':
continue
op = self._operations[item['active_operation']]
elapsed = min(ZIATH_DP5_SCAN_S, world_time_s - op['started_s'])
item['state']['acquisition.elapsed_s'] = elapsed
item['state']['acquisition.progress'] = elapsed / ZIATH_DP5_SCAN_S
op['elapsed_s'] = elapsed
if elapsed >= ZIATH_DP5_SCAN_S:
item['state']['acquisition.status'] = 'succeeded'
op['status'] = 'succeeded'
item['state']['results.data'] = self._scan_result(item, op['started_s'] + ZIATH_DP5_SCAN_S)
item['revision'] += 1
self.time_s = float(world_time_s)
return {'time_s': self.time_s}
def debug_snapshot(self):
with self._lock:
return _dp5_copy.deepcopy({'time_s': self.time_s, 'instances': {k: {field: val for field, val in v.items() if field != 'adapter'} for k, v in self._instances.items()}, 'operations': self._operations})
def _response(self, instance_id, request_id=None, *, status='succeeded', result=None, operation_id=None, code=None, side_effects='none'):
item = self._get(instance_id)
return {'protocol_version': '1.0.0', 'instance_id': instance_id, 'request_id': request_id, 'operation_id': operation_id,
'status': status, 'state_revision': item['revision'] if item else None, 'clock': {'domain': 'simulation', 'time_s': self.time_s},
'result': _dp5_copy.deepcopy(result), 'observations': {},
'error': None if code is None else {'code': code, 'message': 'Operation not permitted or could not be confirmed: ' + code,
'retryable': False, 'side_effects': side_effects, 'known_progress': None}}
@staticmethod
def _operation_result(op):
return {'operation_id': op['id'], 'status': op['status'], 'elapsed_s': op['elapsed_s'],
'progress': op['elapsed_s'] / ZIATH_DP5_SCAN_S, 'results_available': op['status'] == 'succeeded'}
def _invoke(self, principal_id, instance_id, cid, args, request_id):
with self._lock:
reject = lambda code, status='rejected', side='none': self._response(instance_id, request_id, status=status, code=code, side_effects=side)
item = self._get(instance_id, principal_id)
if item is None:
return reject('UNKNOWN_INSTANCE')
if not isinstance(cid, str) or cid not in _DP5_COMPONENTS:
return reject('UNKNOWN_CAPABILITY')
if not isinstance(request_id, str) or not request_id or not isinstance(args, dict):
return reject('INVALID_ARGUMENT')
try:
fingerprint = _dp5_json.dumps([cid, args], sort_keys=True, allow_nan=False, separators=(',', ':'))
except (TypeError, ValueError, OverflowError):
return reject('INVALID_ARGUMENT')
key = (principal_id, instance_id, request_id)
if key in self._requests:
old_fingerprint, old_response = self._requests[key]
return _dp5_copy.deepcopy(old_response) if old_fingerprint == fingerprint else reject('REQUEST_CONFLICT')
required = {'power.set': ['enabled'], 'configuration.set': ['rack_format', 'identity_matching', 'export_format'],
'acquisition.start': [], 'acquisition.poll': ['operation_id'], 'acquisition.cancel': ['operation_id'],
'results.export': ['format'], 'scene.set_rack_lift': ['lift_m']}[cid]
valid = set(args) == set(required)
if valid and cid == 'power.set': valid = type(args['enabled']) is bool
if valid and cid == 'configuration.set': valid = type(args['rack_format']) is int and args['rack_format'] in ZIATH_DP5_FORMATS and type(args['identity_matching']) is bool and args['export_format'] in ('json', 'csv')
if valid and cid in ('acquisition.poll', 'acquisition.cancel'): valid = isinstance(args['operation_id'], str) and bool(args['operation_id'])
if valid and cid == 'results.export': valid = isinstance(args['format'], str) and args['format'] in ('json', 'csv')
if valid and cid == 'scene.set_rack_lift': valid = _dp5_number(args['lift_m']) and 0 <= args['lift_m'] <= .10
if not valid:
return reject('INVALID_ARGUMENT')
s = item['state']
if cid in ('configuration.set', 'acquisition.start') and not s['power.enabled']:
return reject('PRECONDITION_FAILED')
if cid in ('configuration.set', 'acquisition.start', 'scene.set_rack_lift') and s['acquisition.status'] == 'running':
return reject('BUSY')
if cid == 'configuration.set' and s['rack.loaded'] and args['rack_format'] != item['rack_format']:
return reject('PRECONDITION_FAILED')
if cid == 'acquisition.start' and (not s['rack.loaded'] or s['scene.rack_lift_m'] != 0.0 or s['configuration.rack_format'] != item['rack_format']):
return reject('PRECONDITION_FAILED')
if cid == 'scene.set_rack_lift' and not s['rack.loaded']:
return reject('PRECONDITION_FAILED')
op = None
if cid in ('acquisition.poll', 'acquisition.cancel'):
op = self._operations.get(args['operation_id'])
if op is None or op['instance_id'] != instance_id or op['principal_id'] != principal_id:
return reject('UNKNOWN_OPERATION')
if cid == 'results.export' and s['results.data'] is None:
return reject('PRECONDITION_FAILED')
if cid in ('power.set', 'configuration.set', 'scene.set_rack_lift'):
if item['adapter'] is None:
return reject('UNSUPPORTED', 'unsupported')
targets = {'power.set': {'power.enabled': args.get('enabled')}, 'configuration.set': {'scene.rack_format': args.get('rack_format')}, 'scene.set_rack_lift': {'scene.rack_lift_m': args.get('lift_m')}}[cid]
try:
confirmed = item['adapter'](instance_id, _dp5_copy.deepcopy(targets)) is True
except Exception:
confirmed = False
if not confirmed:
response = reject('DEVICE_ERROR', 'failed', 'unknown')
self._requests[key] = (fingerprint, _dp5_copy.deepcopy(response))
return response
status, operation_id = 'succeeded', None
if cid == 'power.set':
s['power.enabled'] = args['enabled']
if not args['enabled'] and s['acquisition.status'] == 'running':
s['acquisition.status'] = 'cancelled'
self._operations[item['active_operation']]['status'] = 'cancelled'
result = {'enabled': args['enabled']}
elif cid == 'configuration.set':
s.update({'configuration.rack_format': args['rack_format'], 'configuration.identity_matching': args['identity_matching'],
'configuration.export_format': args['export_format'], 'scene.rack_format': args['rack_format']})
self._invalidate(item)
result = _dp5_copy.deepcopy(args)
elif cid == 'scene.set_rack_lift':
s['scene.rack_lift_m'] = float(args['lift_m'])
result = {'lift_m': s['scene.rack_lift_m']}
elif cid == 'acquisition.start':
self._invalidate(item)
operation_id = 'scan_%s_%d' % (instance_id, self._next_operation)
self._next_operation += 1
op = {'id': operation_id, 'instance_id': instance_id, 'principal_id': principal_id, 'started_s': self.time_s, 'status': 'running', 'elapsed_s': 0.0}
self._operations[operation_id] = op
item['active_operation'] = operation_id
s['acquisition.status'] = 'running'
result = self._operation_result(op)
status = 'accepted'
elif cid in ('acquisition.poll', 'acquisition.cancel'):
operation_id = op['id']
if cid == 'acquisition.cancel' and op['status'] == 'running':
op['status'] = 'cancelled'
s['acquisition.status'] = 'cancelled'
result = self._operation_result(op)
else:
data, fmt = s['results.data'], args['format']
if fmt == 'json':
content = _dp5_json.dumps(data, ensure_ascii=False, sort_keys=True)
media_type = 'application/json'
else:
buffer = _dp5_io.StringIO(newline='')
writer = _dp5_csv.DictWriter(buffer, fieldnames=['well_id', 'tube_id', 'status', 'expected_tube_id'])
writer.writeheader()
writer.writerows(data['mapping'])
content, media_type = buffer.getvalue(), 'text/csv'
result = {'format': fmt, 'media_type': media_type, 'content': content, 'row_count': len(data['mapping'])}
if cid not in ('acquisition.poll', 'results.export'):
item['revision'] += 1
response = self._response(instance_id, request_id, status=status, result=result, operation_id=operation_id)
self._requests[key] = (fingerprint, _dp5_copy.deepcopy(response))
return response
class ZiathDP5Session:
"""Agent-safe transport surface when host objects/files are not exposed."""
def __init__(self, host, principal_id):
self.__host, self.__principal_id = host, principal_id
def describe(self, *, asset_type_id=None, instance_id=None):
with self.__host._lock:
if (asset_type_id is None) == (instance_id is None):
raise ValueError('Exactly one type or instance identifier required')
if (asset_type_id is not None and asset_type_id != ZIATH_DP5_TYPE) or (instance_id is not None and self.__host._get(instance_id, self.__principal_id) is None):
return self.__host._response(instance_id, status='rejected', code='UNKNOWN_INSTANCE')
metadata = export_ziath_dp5_contract_metadata()
metadata.pop('host_api')
if self.__host._principals[self.__principal_id][0] == 'agent':
metadata['state_slots'] = {k: v for k, v in metadata['state_slots'].items() if v['visibility'] == 'agent'}
metadata['instance_id'] = instance_id
if instance_id is not None and self.__host._instances[instance_id]['adapter'] is None:
for cid in ('power.set', 'configuration.set', 'scene.set_rack_lift'):
metadata['capabilities'][cid]['availability'] = 'unsupported'
return metadata
def read(self, *, instance_id, state_ids=None):
with self.__host._lock:
host = self.__host
item = host._get(instance_id, self.__principal_id)
if item is None:
return host._response(instance_id, status='rejected', code='UNKNOWN_INSTANCE')
visibility = host._principals[self.__principal_id][0]
allowed = {sid for sid, slot in _DP5_SLOTS.items() if visibility != 'agent' or slot['visibility'] == 'agent'}
if state_ids is None:
state_ids = sorted(allowed)
if not isinstance(state_ids, list) or any(not isinstance(sid, str) or sid not in allowed for sid in state_ids):
return host._response(instance_id, status='rejected', code='ACCESS_DENIED')
response = host._response(instance_id)
for sid in state_ids:
value = _dp5_copy.deepcopy(item['state'][sid])
quality = 'unavailable' if value is None else 'estimated' if sid == 'results.data' else 'valid'
response['observations'][sid] = {'value': value, 'unit': _DP5_SLOTS[sid]['unit'], 'quality': quality,
'sample_time_s': host.time_s, 'sample_window_s': None}
if value is None:
response['observations'][sid]['unavailable_reason'] = 'scan_not_completed' if sid == 'results.data' else 'not_configured'
return response
def invoke(self, *, instance_id, capability_id, arguments, request_id):
return self.__host._invoke(self.__principal_id, instance_id, capability_id, arguments, request_id)
def write(self, *, instance_id, state_id, value, request_id):
slot = _DP5_SLOTS.get(state_id) if isinstance(state_id, str) else None
if slot is None or slot['write_via'] is None:
return self.__host._response(instance_id, request_id, status='rejected', code='ACCESS_DENIED')
via = slot['write_via']
return self.invoke(instance_id=instance_id, capability_id=via['capability_id'], arguments={via['parameter']: value}, request_id=request_id)
def poll(self, *, instance_id, operation_id):
with self.__host._lock:
item = self.__host._get(instance_id, self.__principal_id)
op = self.__host._operations.get(operation_id) if isinstance(operation_id, str) else None
if item is None:
return self.__host._response(instance_id, status='rejected', code='UNKNOWN_INSTANCE')
if op is None or op['instance_id'] != instance_id or op['principal_id'] != self.__principal_id:
return self.__host._response(instance_id, status='rejected', code='UNKNOWN_OPERATION')
return self.__host._response(instance_id, result=self.__host._operation_result(op), operation_id=operation_id, status=op['status'])
def cancel(self, *, instance_id, operation_id, request_id):
return self.invoke(instance_id=instance_id, capability_id='acquisition.cancel', arguments={'operation_id': operation_id}, request_id=request_id)
# END CHEM-179 ZIATH DP5 MIRAGE APPEND-ONLY RUNTIME
# BEGIN CHEM-179 ZIATH DP5 HOST RACK REMOVAL EXTENSION
# Append-only extension: the host registers an already-performed external removal.
def _dp5_host_unload_rack(self, instance_id):
with self._lock:
item = self._get(instance_id)
if item is None or not item['state']['rack.loaded'] or item['state']['acquisition.status'] == 'running' or item['state']['rack.attachment_constraint_id'] is not None:
raise ValueError('Loaded idle unattached rack required for host removal registration')
removed_id = item['state']['rack.rack_id']
item['state'].update({'rack.loaded': False, 'rack.rack_id': None, 'rack.well_ids': [], 'truth.visible_barcodes': [], 'truth.task_manifest': []})
item['rack_format'] = None
self._invalidate(item)
item['revision'] += 1
return {'rack_id': removed_id, 'event': 'unload_registered'}
ZiathDP5Runtime.host_unload_rack = _dp5_host_unload_rack
_dp5_export_base = export_ziath_dp5_contract_metadata
def export_ziath_dp5_contract_metadata():
metadata = _dp5_export_base()
metadata['capabilities']['configuration.set']['description_zh'] = '设置容量、身份匹配和可供宿主UI读取的导出偏好；清除上次结果。results.export仍须显式提供format。'
metadata['capabilities']['configuration.set']['name_zh'] = metadata['capabilities']['configuration.set']['description_zh']
metadata['host_api']['host_unload_rack'] = {'entrypoint': 'ZiathDP5Runtime.host_unload_rack(instance_id)', 'description_zh': '可信宿主登记已完成的外部管架移出；要求idle且无附着，清空输入/结果，可随后更换容量。不创建机械位移；实际样品容器存在性由宿主世界管理。'}
metadata['limitations'].append('configuration.export_format是供宿主UI读取的导出偏好；results.export必须显式选json/csv。host_unload_rack仅登记外部移出，容器存在性和移出动作由宿主世界管理。')
return metadata
# END CHEM-179 ZIATH DP5 HOST RACK REMOVAL EXTENSION
# BEGIN CHEM-179 ZIATH DP5 HISTORICAL OPERATION RESULT AVAILABILITY
# A completed historical scan can outlive the current rack/result cache.
# Fresh queries must not claim those discarded results can still be exported.
_dp5_invoke_base = ZiathDP5Runtime._invoke
def _dp5_invoke_with_current_results(self, principal_id, instance_id, cid, args, request_id):
with self._lock:
key = (principal_id, instance_id, request_id) if isinstance(instance_id, str) and isinstance(request_id, str) else None
cached_before = key in self._requests if key is not None else False
response = _dp5_invoke_base(self, principal_id, instance_id, cid, args, request_id)
if not cached_before and cid in ('acquisition.poll', 'acquisition.cancel') and response['error'] is None:
item = self._instances[instance_id]
response['result']['results_available'] = item['active_operation'] == response['operation_id'] and item['state']['results.data'] is not None
if key in self._requests:
fingerprint, _ = self._requests[key]
self._requests[key] = (fingerprint, _dp5_copy.deepcopy(response))
if response['error'] is not None and response['error']['code'] == 'UNKNOWN_INSTANCE':
response['state_revision'] = None
return response
ZiathDP5Runtime._invoke = _dp5_invoke_with_current_results
_dp5_poll_base = ZiathDP5Session.poll
def _dp5_poll_current_results(self, *, instance_id, operation_id):
host = self._ZiathDP5Session__host
with host._lock:
response = _dp5_poll_base(self, instance_id=instance_id, operation_id=operation_id)
if response['error'] is None:
item = host._instances[instance_id]
response['result']['results_available'] = item['active_operation'] == operation_id and item['state']['results.data'] is not None
elif response['error']['code'] == 'UNKNOWN_INSTANCE':
response['state_revision'] = None
return response
ZiathDP5Session.poll = _dp5_poll_current_results
_dp5_metadata_before_history = export_ziath_dp5_contract_metadata
def export_ziath_dp5_contract_metadata():
metadata = _dp5_metadata_before_history()
metadata['limitations'].append('只保留当前管架/当前扫描的可导出结果；历史operation_id可查完成或取消状态，新的poll会将已清除结果标results_available=false。同request_id重放返回原响应，使用Session.poll读取最新进度。')
return metadata
# END CHEM-179 ZIATH DP5 HISTORICAL OPERATION RESULT AVAILABILITY
# BEGIN CHEM-177 INTELLIXCAP S1 APPEND-ONLY RUNTIME
"""Semi-automatic CHEM-177 motion demonstration, not a thread/contact solver.
The trusted host supplies all motion assumptions and confirms external
attachment/release constraints. Give agents a session, never the host object.
API filtering is not a Python-introspection or filesystem security boundary.
"""
import copy as _ixs_copy
import hashlib as _ixs_hashlib
import json as _ixs_json
import math as _ixs_math
import threading as _ixs_threading
import uuid as _ixs_uuid
INTELLIXCAP_S1_TYPE = "instrument.azenta_intellixcap_s1_46_0001"
def _ixs_number(value):
try:
return type(value) in (int, float) and _ixs_math.isfinite(value)
except (TypeError, ValueError, OverflowError):
return False
def _ixs_text(value):
return isinstance(value, str) and bool(value.strip())
def _ixs_num(unit, minimum=None, maximum=None, nullable=False):
spec = {"type": "number", "x-unit": unit}
if minimum is not None:
spec["minimum"] = minimum
if maximum is not None:
spec["maximum"] = maximum
return {"anyOf": [spec, {"type": "null"}]} if nullable else spec
def _ixs_obj(props):
return {"type": "object", "properties": props, "required": list(props), "additionalProperties": False}
_IXS_STRING_NULL = {"anyOf": [{"type": "string"}, {"type": "null"}]}
_IXS_BOOL_NULL = {"anyOf": [{"type": "boolean"}, {"type": "null"}]}
_IXS_STATUS = {"type": "string", "enum": ["idle", "clamping", "awaiting_attach", "rotating", "awaiting_thread_result", "awaiting_release", "releasing", "succeeded", "failed", "cancelled"]}
_IXS_LIMITATIONS = [
"仅实现半自动单管状态机与合成运动；完整无人流程需要宿主样品转运。robot 和 hardware 层 absent。",
"所有行程、转角和阶段时长必须由可信宿主给出显式仿真假设与证据；没有厂家运动缺省值。",
"典型周期小于3秒随耗材变化；该规格不是此仿真每次周期的保证，也不用作默认运动或超时参数。",
"11–40 mm仅为盖径兼容范围；15/50 mL是已列兼容管容量类别，不能据容量推导管形或螺距。",
"夹持和旋转仅提供位姿状态；扭矩、夹力、螺纹摩擦、转速和实际行程未知且不求解。",
"attach/release事件需宿主实际建立/解除外部约束后确认；本运行层只登记constraint_id，不创建物理约束。",
"运动结束后必须等待宿主螺纹结果；结果属于宿主断言，不是本资产自行检测到的真实开封盖成功。",
"取消保留关节当前位置及已确认附着；不得假定盖已释放、样品状态回滚或自动复位。",
"read/poll不推进时间；host_step推进同一运行宿主中全部实例。实例数据互相隔离。",
"去重只在当前宿主内存中有效；API可见性过滤不构成Python反射或共享文件系统隔离。",
]
def export_intellixcap_s1_contract_metadata():
"""Complete slot/capability fragments using artifact runtime and stable IDs."""
definitions = {
"power.enabled": ({"type": "boolean"}, "1", "setpoint", "controller", "仿真供电开关；空闲才可修改", "power.set", "enabled"),
"cycle.mode": ({"type": "string", "enum": ["decap", "recap"]}, "1", "setpoint", "controller", "下一周期的开盖或封盖模式", "cycle.set_mode", "mode"),
"sample.consumable_id": (_IXS_STRING_NULL, "1", "setpoint", "sample_interface", "宿主登记的兼容耗材类型ID", "consumable.select", "consumable_id"),
"sample.tube_id": (_IXS_STRING_NULL, "1", "scene", "sample_interface", "宿主放入的单管实例引用；不含样品成分", None, None),
"sample.cap_id": (_IXS_STRING_NULL, "1", "scene", "sample_interface", "宿主放入的螺纹盖实例引用", None, None),
"attachment.constraint_id": (_IXS_STRING_NULL, "1", "scene", "gripper", "宿主确认已存在的夹爪—管盖约束ID", None, None),
"simulation.motion_configured": ({"type": "boolean"}, "1", "derived", "controller", "宿主是否明确配置了运动演示参数和证据", None, None),
"rotation_rad": (_ixs_num("rad", nullable=True), "rad", "scene", "spindle", "绕主轴本地+Z的演示角；正向定义为开盖，非厂家方向证据", None, None),
"jaw_gap_m": (_ixs_num("m", 0, nullable=True), "m", "scene", "gripper", "相对主轴的两个夹爪内表面总间距；不表示接触夹紧力", None, None),
"cycle.status": (_IXS_STATUS, "1", "derived", "controller", "异步状态机阶段；等待宿主时不继续自动执行", None, None),
"cycle.motion_completed": ({"type": "boolean"}, "1", "derived", "controller", "旋转演示已完成；不能单独证明螺纹开封盖成功", None, None),
"cycle.host_confirmed": (_IXS_BOOL_NULL, "1", "derived", "controller", "宿主显式确认的螺纹结果，未确认是null", None, None),
"truth.thread_state": ({"anyOf": [{"type": "string", "enum": ["open", "closed"]}, {"type": "null"}]}, "1", "process_truth", "sample_interface", "宿主确认的管盖开闭真值；运行层不自行计算", None, None),
}
slots = {}
for sid, (schema, unit, origin, component, meaning, cid, argument) in definitions.items():
slots[sid] = {"component_ids": [component], "value_schema": _ixs_copy.deepcopy(schema), "unit": unit,
"reference_conditions": "Spindle local +Z; symmetric gripper local X inner-face spacing" if sid in ("rotation_rad", "jaw_gap_m") else None,
"meaning_zh": meaning, "origin": origin, "access": "read_write" if cid else "read_only", "visibility": "debug" if origin == "process_truth" else "agent",
"read_binding": {"backend": "host", "artifact_id": "runtime", "accessor": "IntelliXcapS1Session.read(instance_id=..., state_ids=['%s'])" % sid},
"write_via": {"capability_id": cid, "argument": argument, "fixed_arguments": {}} if cid else None,
"sampling": {"mode": "instant", "time_domain": "simulation", "window_description": None}, "source_ids": ["runtime", "assumptions"]}
progress_ids = ["cycle.status", "cycle.motion_completed", "cycle.host_confirmed", "rotation_rad", "jaw_gap_m", "attachment.constraint_id"]
capdefs = {
"power.set": ("空闲时设置仿真供电", {"enabled": {"type": "boolean"}}, ["power.enabled"], {"enabled": True}, ["controller"]),
"cycle.set_mode": ("空闲时设置开盖/封盖模式", {"mode": {"type": "string", "enum": ["decap", "recap"]}}, ["cycle.mode"], {"mode": "decap"}, ["controller"]),
"consumable.select": ("选择有宿主兼容证据的耗材类型", {"consumable_id": {"type": "string"}}, ["sample.consumable_id"], {"consumable_id": "synthetic_15ml_type"}, ["sample_interface", "controller"]),
"cycle.start": ("启动夹持及旋转演示；分阶段等待宿主约束与螺纹结果", {}, progress_ids, {}, ["controller", "spindle", "gripper", "sample_interface"]),
"cycle.read": ("查询当前周期及机械状态，不推进时间", {}, progress_ids, {}, ["controller", "spindle", "gripper"]),
"torque.set_limit": ("扭矩阈值未公开且无力学控制实现", {}, [], {}, ["controller", "spindle"]),
}
caps = {}
for cid, (function, props, result_ids, example, components) in capdefs.items():
async_cycle = cid == "cycle.start"
unsupported = cid == "torque.set_limit"
query = cid == "cycle.read"
effects = [] if query or unsupported else [{"state_id": sid, "timing": "immediate", "description_zh": "写入已校验设定或初始化周期状态；撤销上次样品真值确认"} for sid in (result_ids if not async_cycle else ["cycle.status", "cycle.motion_completed", "cycle.host_confirmed", "truth.thread_state"])]
if async_cycle:
effects += [{"state_id": sid, "timing": "on_step", "description_zh": "宿主公共时钟推进合成关节运动或状态阶段"} for sid in ["rotation_rad", "jaw_gap_m", "cycle.status", "cycle.motion_completed"]]
effects += [{"state_id": sid, "timing": "external", "description_zh": "宿主确认外部附着、释放或螺纹结果后更新"} for sid in ["attachment.constraint_id", "cycle.host_confirmed", "truth.thread_state"]]
caps[cid] = {"function_zh": function, "kind": "query" if query else "configuration" if cid in ("consumable.select", "cycle.set_mode") else "device_command",
"visibility": "agent", "component_ids": components, "availability": "unsupported" if unsupported else "implemented",
"input_schema": _ixs_obj(props), "output_schema": _ixs_obj({sid: _ixs_copy.deepcopy(slots[sid]["value_schema"]) for sid in result_ids}),
"implementation": {"process": "absent", "scene": "declared" if async_cycle else "not_applicable", "robot": "absent", "hardware": "absent", "host": "absent" if unsupported else "implemented"},
"binding": None if unsupported else {"backend": "host", "artifact_id": "runtime", "entrypoint": "basic40_runtime_automation.IntelliXcapS1Session.invoke", "invocation": "session.invoke(instance_id=..., capability_id='%s', arguments=..., request_id=...)" % cid},
"preconditions": [] if query or unsupported else [{"description_zh": "写设定要求没有活动周期且没有附着；启动还要求供电、已选兼容耗材、匹配的管盖、明确运动配置和张开姿态", "state_ids": ["power.enabled", "sample.consumable_id", "sample.tube_id", "sample.cap_id", "simulation.motion_configured", "attachment.constraint_id", "cycle.status"], "enforced_by": "runtime", "check": "IntelliXcapS1Session._execute checks active operation, attachment, registered compatibility and ready pose before commit"}],
"state_effects": effects, "observes": result_ids,
"model_effects": {"mode": "host_required" if async_cycle else "none", "binding_ids": [], "description_zh": "宿主将host_motion_snapshot中的rotation_rad/jaw_gap_m绑定到场景关节；约束另由宿主完成" if async_cycle else "该操作不直接改变几何关节"},
"execution": {"mode": "asynchronous" if async_cycle else "synchronous", "time_domain": "simulation", "completion_criterion": "所有演示阶段结束且宿主确认螺纹成功和外部释放后succeeded；false结果在释放后failed" if async_cycle else "响应已校验且设定已写入，或返回当前读数；unsupported不执行", "completion_state_ids": result_ids,
"timeout_s": None, "cancellation": "supported" if async_cycle else "unsupported", "retry": "same_request_id", "resources": ["single_tube_workcell"] if async_cycle else [], "partial_failure_zh": "取消冻结当前姿态并保留现有约束；宿主需处理外部样品和释放，绝不自动回滚。拒绝不改变实例状态。"},
"errors": [{"code": code, "meaning_zh": meaning, "side_effects": "none"} for code, meaning in [("UNKNOWN_INSTANCE", "实例不可访问"), ("UNKNOWN_CAPABILITY", "能力不存在"), ("INVALID_ARGUMENT", "参数类型、单位范围或字段不符"), ("PRECONDITION_FAILED", "缺少兼容性、样品、运动配置或张开条件"), ("BUSY", "已有活动周期或外部附着未解除"), ("ACCESS_DENIED", "身份或操作作用域不足"), ("REQUEST_CONFLICT", "请求ID被不同参数复用"), ("UNSUPPORTED", "扭矩控制尚未实现")]] + ([{"code": "HOST_REPORTED_FAILURE", "meaning_zh": "宿主报告开封盖失败；运动和外部约束已发生", "side_effects": "partial"}] if async_cycle else []),
"example_arguments": example, "verification": [], "limitations": list(_IXS_LIMITATIONS), "source_ids": ["catalog", "runtime", "assumptions"]}
return {"asset_type_id": INTELLIXCAP_S1_TYPE, "asset_version": "1.0.1", "catalog_id": "CHEM-177", "state_slots": slots, "capabilities": caps,
"parameters": {"cap_diameter_min_m": 0.011, "cap_diameter_max_m": 0.040, "nominal_tube_volume_classes_m3": [15e-6, 50e-6], "typical_cycle_upper_exclusive_s": 3.0, "typical_cycle_note": "depends on consumable; not runtime default", "whole_instrument_dimensions_xyz_m": [0.170, 0.240, 0.300], "whole_instrument_mass_kg": 3.8, "supply_voltage_V": 24.0, "supply_current_A": 2.7,
"default_rotation_delta_rad": None, "default_jaw_travel_m": None, "default_cycle_duration_s": None, "torque_limit_N_m": None, "clamp_force_N": None, "spindle_speed_rad_s": None, "component_masses_kg": None},
"host_api": {"host_register_consumable": "Explicit compatible type, cap_diameter_m 0.011..0.040, optional nominal_volume_m3 and compatibility_evidence; no bundled library",
"host_present_sample": "Explicit tube_id, cap_id, consumable_id and placement evidence; no robot placement",
"host_configure_motion": "Explicit open_gap_m, closed_gap_m, rotation_delta_rad, initial_rotation_rad, clamp_duration_s, rotation_duration_s, release_duration_s and evidence; all unknown by default",
"host_events": "Returns attach/release requests with event_id; does not make constraints",
"host_confirm_attachment": "Confirms host actually created named constraint for outstanding attach event",
"host_confirm_thread_result": "Explicit succeeded bool and evidence only after rotation demonstration completed",
"host_confirm_release": "Confirms host actually removed current constraint; after cancellation can release retained constraint without resuming motion",
"host_motion_snapshot": "instance_id, state_revision, time_s, rotation_rad, jaw_gap_m; authoritative motion values for scene sync",
"host_step": "Advance one common simulation clock for all instances; no per-instance implicit time"}, "limitations": list(_IXS_LIMITATIONS)}
class IntelliXcapS1Runtime:
"""Trusted multi-instance host. External callers receive authenticated sessions."""
def __init__(self):
self.time_s = 0.0
self._instances, self._consumables, self._principals = {}, {}, {}
self._operations, self._requests = {}, {}
self._lock = _ixs_threading.RLock()
def create_instance(self, instance_id):
with self._lock:
if not _ixs_text(instance_id) or instance_id in self._instances:
raise ValueError("Unique nonempty instance_id required")
values = {sid: None for sid in export_intellixcap_s1_contract_metadata()["state_slots"]}
values.update({"power.enabled": False, "cycle.mode": "decap", "simulation.motion_configured": False, "cycle.status": "idle", "cycle.motion_completed": False})
self._instances[instance_id] = {"instance_id": instance_id, "values": values, "revision": 0, "motion": None, "sample": None, "active_operation_id": None, "events": []}
def register_principal(self, principal_id, *, visibility, instance_ids=None):
with self._lock:
if not _ixs_text(principal_id) or principal_id in self._principals or visibility not in ("agent", "debug", "evaluator"):
raise ValueError("Host-assigned principal and visibility required")
if instance_ids is not None and (not isinstance(instance_ids, (list, tuple, set, frozenset)) or any(not isinstance(s, str) or s not in self._instances for s in instance_ids)):
raise ValueError("Invalid instance scope")
self._principals[principal_id] = (visibility, None if instance_ids is None else frozenset(instance_ids))
def session(self, principal_id):
with self._lock:
if not isinstance(principal_id, str) or principal_id not in self._principals:
raise ValueError("Host authentication required")
return IntelliXcapS1Session(self, principal_id)
def _inst(self, instance_id):
if not isinstance(instance_id, str) or instance_id not in self._instances:
raise ValueError("Unknown instance")
return self._instances[instance_id]
def _idle(self, inst):
if inst["active_operation_id"] is not None or inst["values"]["attachment.constraint_id"] is not None:
raise ValueError("Active operation or attachment requires explicit recovery")
@staticmethod
def _commit(inst, values):
if values != inst["values"]:
inst["values"] = values
inst["revision"] += 1
def host_register_consumable(self, consumable_id, *, cap_diameter_m, compatibility_evidence, nominal_volume_m3=None):
with self._lock:
if not _ixs_text(consumable_id) or consumable_id in self._consumables or not _ixs_text(compatibility_evidence) or not _ixs_number(cap_diameter_m) or not 0.011 <= cap_diameter_m <= 0.040:
raise ValueError("Explicit compatible consumable and 11–40 mm cap required")
if nominal_volume_m3 is not None and (not _ixs_number(nominal_volume_m3) or nominal_volume_m3 <= 0):
raise ValueError("Optional nominal capacity must be positive SI volume")
self._consumables[consumable_id] = {"cap_diameter_m": float(cap_diameter_m), "nominal_volume_m3": nominal_volume_m3, "evidence": compatibility_evidence}
def host_present_sample(self, instance_id, *, tube_id, cap_id, consumable_id, evidence):
with self._lock:
inst = self._inst(instance_id)
self._idle(inst)
if not all(_ixs_text(x) for x in (tube_id, cap_id, consumable_id, evidence)) or tube_id == cap_id or consumable_id not in self._consumables:
raise ValueError("Registered consumable and distinct tube/cap references with placement evidence required")
if any(other is not inst and other["sample"] is not None and (tube_id in (other["sample"]["tube_id"], other["sample"]["cap_id"]) or cap_id in (other["sample"]["tube_id"], other["sample"]["cap_id"])) for other in self._instances.values()):
raise ValueError("Sample entity is already assigned to another instance")
inst["sample"] = {"tube_id": tube_id, "cap_id": cap_id, "consumable_id": consumable_id, "evidence": evidence}
s = _ixs_copy.deepcopy(inst["values"])
s.update({"sample.tube_id": tube_id, "sample.cap_id": cap_id, "truth.thread_state": None, "cycle.host_confirmed": None})
self._commit(inst, s)
def host_configure_motion(self, instance_id, *, open_gap_m, closed_gap_m, rotation_delta_rad, initial_rotation_rad, clamp_duration_s, rotation_duration_s, release_duration_s, evidence):
with self._lock:
inst = self._inst(instance_id)
self._idle(inst)
numbers = [open_gap_m, closed_gap_m, rotation_delta_rad, initial_rotation_rad, clamp_duration_s, rotation_duration_s, release_duration_s]
if not all(_ixs_number(v) for v in numbers) or not _ixs_text(evidence) or not open_gap_m > closed_gap_m >= 0 or min(rotation_delta_rad, clamp_duration_s, rotation_duration_s, release_duration_s) <= 0:
raise ValueError("Finite explicit motion values, positive durations/angle, open>closed>=0 and evidence required")
if not _ixs_number(initial_rotation_rad + rotation_delta_rad) or not _ixs_number(initial_rotation_rad - rotation_delta_rad):
raise ValueError("Motion angle would overflow")
inst["motion"] = {"open_gap_m": float(open_gap_m), "closed_gap_m": float(closed_gap_m), "rotation_delta_rad": float(rotation_delta_rad), "initial_rotation_rad": float(initial_rotation_rad), "clamp_duration_s": float(clamp_duration_s), "rotation_duration_s": float(rotation_duration_s), "release_duration_s": float(release_duration_s), "evidence": evidence}
s = _ixs_copy.deepcopy(inst["values"])
s.update({"rotation_rad": float(initial_rotation_rad), "jaw_gap_m": float(open_gap_m), "simulation.motion_configured": True})
self._commit(inst, s)
def _event(self, inst, op, kind, time_s):
event = {"event_id": "ixs_evt_" + _ixs_uuid.uuid4().hex, "kind": kind, "operation_id": op["operation_id"], "instance_id": inst["instance_id"], "time_s": time_s, "tube_id": inst["values"]["sample.tube_id"], "cap_id": inst["values"]["sample.cap_id"], "target_component_id": "gripper", "constraint_id": inst["values"]["attachment.constraint_id"], "acknowledged": False}
inst["events"].append(event)
op["pending_event_id"] = event["event_id"]
def host_events(self, instance_id):
with self._lock:
return _ixs_copy.deepcopy(self._inst(instance_id)["events"])
def _operation_for_host(self, instance_id, operation_id, expected_phase):
inst = self._inst(instance_id)
op = self._operations.get(operation_id) if isinstance(operation_id, str) else None
if op is None or op["instance_id"] != instance_id or op["phase"] not in expected_phase:
raise ValueError("Operation does not match required host-confirmation phase")
return inst, op
def _pending_event(self, inst, op, event_id, kind):
if not isinstance(event_id, str) or event_id != op["pending_event_id"]:
raise ValueError("Outstanding event ID must match")
event = next((e for e in inst["events"] if e["event_id"] == event_id and e["kind"] == kind and not e["acknowledged"]), None)
if event is None:
raise ValueError("Outstanding event unavailable")
return event
def host_confirm_attachment(self, instance_id, *, operation_id, event_id, constraint_id, evidence):
with self._lock:
inst, op = self._operation_for_host(instance_id, operation_id, ["awaiting_attach"])
event = self._pending_event(inst, op, event_id, "attach")
if not _ixs_text(constraint_id) or not _ixs_text(evidence) or any(other["values"]["attachment.constraint_id"] == constraint_id for other in self._instances.values()):
raise ValueError("Unique externally created constraint and evidence required")
event.update({"acknowledged": True, "confirmed_constraint_id": constraint_id, "evidence": evidence})
op.update({"phase": "rotating", "phase_start_s": self.time_s, "pending_event_id": None})
s = _ixs_copy.deepcopy(inst["values"])
s.update({"attachment.constraint_id": constraint_id, "cycle.status": "rotating"})
self._commit(inst, s)
def host_confirm_thread_result(self, instance_id, *, operation_id, succeeded, evidence):
with self._lock:
inst, op = self._operation_for_host(instance_id, operation_id, ["awaiting_thread_result"])
if type(succeeded) is not bool or not _ixs_text(evidence):
raise ValueError("Explicit host result and evidence required")
op.update({"phase": "awaiting_release", "thread_evidence": evidence})
s = _ixs_copy.deepcopy(inst["values"])
s.update({"cycle.host_confirmed": succeeded, "cycle.status": "awaiting_release", "truth.thread_state": ("open" if op["mode"] == "decap" else "closed") if succeeded else None})
self._commit(inst, s)
self._event(inst, op, "release", self.time_s)
def host_confirm_release(self, instance_id, *, operation_id, event_id, constraint_id, evidence):
with self._lock:
inst, op = self._operation_for_host(instance_id, operation_id, ["awaiting_release", "cancelled"])
event = self._pending_event(inst, op, event_id, "release")
if not _ixs_text(constraint_id) or constraint_id != inst["values"]["attachment.constraint_id"] or not _ixs_text(evidence):
raise ValueError("Current external constraint and removal evidence required")
event.update({"acknowledged": True, "evidence": evidence})
s = _ixs_copy.deepcopy(inst["values"])
s["attachment.constraint_id"] = None
op["pending_event_id"] = None
if op["phase"] != "cancelled":
op.update({"phase": "releasing", "phase_start_s": self.time_s})
s["cycle.status"] = "releasing"
self._commit(inst, s)
op["result"] = self._progress(inst)
def host_step(self, dt_s):
with self._lock:
if not _ixs_number(dt_s) or dt_s < 0 or not _ixs_number(self.time_s + dt_s):
raise ValueError("Finite nonnegative common-clock step required")
next_time = self.time_s + dt_s
for inst in self._instances.values():
op = self._operations.get(inst["active_operation_id"])
if op is None or op["phase"] not in ("clamping", "rotating", "releasing"):
continue
s, m = _ixs_copy.deepcopy(inst["values"]), inst["motion"]
phase = op["phase"]
duration = m[{"clamping": "clamp_duration_s", "rotating": "rotation_duration_s", "releasing": "release_duration_s"}[phase]]
fraction = min(1.0, max(0.0, (next_time - op["phase_start_s"]) / duration))
if phase == "clamping":
s["jaw_gap_m"] = m["open_gap_m"] * (1-fraction) + m["closed_gap_m"] * fraction
elif phase == "rotating":
s["rotation_rad"] = op["rotation_start_rad"] + op["signed_rotation_delta_rad"] * fraction
else:
s["jaw_gap_m"] = m["closed_gap_m"] * (1-fraction) + m["open_gap_m"] * fraction
if fraction == 1.0:
phase = {"clamping": "awaiting_attach", "rotating": "awaiting_thread_result", "releasing": "succeeded" if s["cycle.host_confirmed"] else "failed"}[phase]
op["phase"] = s["cycle.status"] = phase
if phase == "awaiting_thread_result":
s["cycle.motion_completed"] = True
if phase in ("succeeded", "failed"):
op["status"] = phase
inst["active_operation_id"] = None
self._commit(inst, s)
if phase == "awaiting_attach":
self._event(inst, op, "attach", op["phase_start_s"] + duration)
else:
self._commit(inst, s)
op["result"] = self._progress(inst)
self.time_s = next_time
@staticmethod
def _progress(inst):
return {sid: _ixs_copy.deepcopy(inst["values"][sid]) for sid in ["cycle.status", "cycle.motion_completed", "cycle.host_confirmed", "rotation_rad", "jaw_gap_m", "attachment.constraint_id"]}
def host_motion_snapshot(self, instance_id):
with self._lock:
inst = self._inst(instance_id)
return {"instance_id": instance_id, "state_revision": inst["revision"], "time_s": self.time_s, "rotation_rad": inst["values"]["rotation_rad"], "jaw_gap_m": inst["values"]["jaw_gap_m"]}
def debug_snapshot(self):
with self._lock:
return _ixs_copy.deepcopy({"time_s": self.time_s, "instances": self._instances, "consumables": self._consumables, "operations": self._operations})
class IntelliXcapS1Session:
"""Agent-facing wrapper; only host-created identity controls access."""
def __init__(self, host, principal_id):
self.__host, self.__principal_id = host, principal_id
def _instance(self, instance_id):
_, scope = self.__host._principals[self.__principal_id]
return self.__host._instances.get(instance_id) if isinstance(instance_id, str) and (scope is None or instance_id in scope) else None
def _visible(self, sid):
slots = export_intellixcap_s1_contract_metadata()["state_slots"]
role, _ = self.__host._principals[self.__principal_id]
return isinstance(sid, str) and sid in slots and (slots[sid]["visibility"] == "agent" or role in ("debug", "evaluator"))
def _envelope(self, instance_id=None, request_id=None, *, status="succeeded", operation_id=None, result=None, observations=None, error=None):
inst = self._instance(instance_id)
return {"protocol_version": "1.0.0", "instance_id": instance_id if isinstance(instance_id, str) else None, "request_id": request_id if isinstance(request_id, str) else None,
"operation_id": operation_id, "status": status, "state_revision": inst["revision"] if inst else None,
"clock": {"domain": "simulation", "time_s": self.__host.time_s}, "result": _ixs_copy.deepcopy(result or {}), "observations": _ixs_copy.deepcopy(observations or {}), "error": error}
def _error(self, instance_id, code, request_id=None, *, status="rejected"):
return self._envelope(instance_id, request_id, status=status, error={"code": code, "message": "Operation unavailable or request does not meet its declared operating/access conditions.", "retryable": False, "side_effects": "none", "progress": None})
def describe(self, *, asset_type_id=None, instance_id=None):
with self.__host._lock:
if (asset_type_id is None) == (instance_id is None):
return self._error(None, "INVALID_ARGUMENT")
if instance_id is not None and self._instance(instance_id) is None:
return self._error(instance_id, "UNKNOWN_INSTANCE")
if asset_type_id is not None and asset_type_id != INTELLIXCAP_S1_TYPE:
return self._error(None, "INVALID_ARGUMENT")
_, scope = self.__host._principals[self.__principal_id]
if scope is not None and not scope:
return self._error(instance_id, "ACCESS_DENIED")
spec = export_intellixcap_s1_contract_metadata()
spec.pop("host_api")
spec["state_slots"] = {sid: slot for sid, slot in spec["state_slots"].items() if self._visible(sid)}
for cap in spec["capabilities"].values():
cap["state_effects"] = [e for e in cap["state_effects"] if self._visible(e["state_id"])]
spec.update({"protocol_version": "1.0.0", "instance_id": instance_id, "adapter": "basic40_runtime_automation.IntelliXcapS1Session"})
return spec
def read(self, *, instance_id, state_ids=None):
with self.__host._lock:
inst = self._instance(instance_id)
if inst is None:
return self._error(instance_id, "UNKNOWN_INSTANCE")
slots = export_intellixcap_s1_contract_metadata()["state_slots"]
if state_ids is None:
state_ids = [sid for sid in slots if self._visible(sid)]
if not isinstance(state_ids, list) or any(not isinstance(s, str) for s in state_ids) or len(set(state_ids)) != len(state_ids):
return self._error(instance_id, "INVALID_ARGUMENT")
if any(not self._visible(sid) for sid in state_ids):
return self._error(instance_id, "ACCESS_DENIED")
observations = {}
for sid in state_ids:
value = _ixs_copy.deepcopy(inst["values"][sid])
observations[sid] = {"value": value, "unit": slots[sid]["unit"], "quality": "unavailable" if value is None else "estimated" if sid in ("rotation_rad", "jaw_gap_m") else "valid", "sample_time_s": self.__host.time_s, "sample_window_s": None}
if value is None:
observations[sid]["reason"] = "No explicit host configuration, sample reference, attachment or confirmation is available for this state."
return self._envelope(instance_id, observations=observations)
def _cached(self, instance_id, request_id, logical, callback):
if not _ixs_text(request_id) or len(request_id) > 256:
return self._error(instance_id, "INVALID_ARGUMENT", request_id)
try:
digest = _ixs_hashlib.sha256(_ixs_json.dumps(logical, sort_keys=True, allow_nan=False, separators=(",", ":")).encode()).hexdigest()
except (TypeError, ValueError, OverflowError, RecursionError):
return self._error(instance_id, "INVALID_ARGUMENT", request_id)
key = (self.__principal_id, instance_id, request_id)
if key in self.__host._requests:
previous, response = self.__host._requests[key]
return _ixs_copy.deepcopy(response) if previous == digest else self._error(instance_id, "REQUEST_CONFLICT", request_id)
response = callback()
self.__host._requests[key] = (digest, _ixs_copy.deepcopy(response))
return response
def invoke(self, *, instance_id, capability_id, arguments, request_id):
with self.__host._lock:
inst = self._instance(instance_id)
if inst is None:
return self._error(instance_id, "UNKNOWN_INSTANCE", request_id)
if not isinstance(capability_id, str) or not isinstance(arguments, dict):
return self._error(instance_id, "INVALID_ARGUMENT", request_id)
return self._cached(instance_id, request_id, ["invoke", capability_id, arguments], lambda: self._execute(inst, capability_id, arguments, request_id))
def _execute(self, inst, cid, args, request_id):
iid = inst["instance_id"]
fail = lambda code: self._error(iid, code, request_id)
caps = export_intellixcap_s1_contract_metadata()["capabilities"]
if cid not in caps:
return fail("UNKNOWN_CAPABILITY")
props = caps[cid]["input_schema"]["properties"]
if set(args) != set(props):
return fail("INVALID_ARGUMENT")
for name, spec in props.items():
value = args[name]
if (spec["type"] == "boolean" and type(value) is not bool) or (spec["type"] == "string" and not _ixs_text(value)) or ("enum" in spec and value not in spec["enum"]):
return fail("INVALID_ARGUMENT")
if cid == "torque.set_limit":
return self._error(iid, "UNSUPPORTED", request_id, status="unsupported")
if cid == "cycle.read":
return self._envelope(iid, request_id, result=self.__host._progress(inst))
s = _ixs_copy.deepcopy(inst["values"])
if inst["active_operation_id"] is not None or s["attachment.constraint_id"] is not None:
return fail("BUSY")
if cid == "power.set":
s["power.enabled"] = args["enabled"]
elif cid == "cycle.set_mode":
s["cycle.mode"] = args["mode"]
elif cid == "consumable.select":
if args["consumable_id"] not in self.__host._consumables:
return fail("PRECONDITION_FAILED")
s["sample.consumable_id"] = args["consumable_id"]
elif cid == "cycle.start":
m, sample = inst["motion"], inst["sample"]
if not s["power.enabled"] or m is None or sample is None or sample["consumable_id"] != s["sample.consumable_id"] or s["jaw_gap_m"] != m["open_gap_m"]:
return fail("PRECONDITION_FAILED")
cap_diameter = self.__host._consumables[sample["consumable_id"]]["cap_diameter_m"]
if not m["closed_gap_m"] <= cap_diameter < m["open_gap_m"]:
return fail("PRECONDITION_FAILED")
delta = m["rotation_delta_rad"] * (1 if s["cycle.mode"] == "decap" else -1)
if not _ixs_number(s["rotation_rad"] + delta):
return fail("INVALID_ARGUMENT")
operation_id = "ixs_op_" + _ixs_uuid.uuid4().hex
s.update({"cycle.status": "clamping", "cycle.motion_completed": False, "cycle.host_confirmed": None, "truth.thread_state": None})
self.__host._commit(inst, s)
op = {"operation_id": operation_id, "instance_id": iid, "principal_id": self.__principal_id, "request_id": request_id, "status": "running", "phase": "clamping", "phase_start_s": self.__host.time_s, "rotation_start_rad": s["rotation_rad"], "signed_rotation_delta_rad": delta, "mode": s["cycle.mode"], "pending_event_id": None, "result": self.__host._progress(inst)}
self.__host._operations[operation_id] = op
inst["active_operation_id"] = operation_id
return self._envelope(iid, request_id, status="accepted", operation_id=operation_id, result=op["result"])
self.__host._commit(inst, s)
return self._envelope(iid, request_id, result={sid: s[sid] for sid in caps[cid]["observes"]})
def write(self, *, instance_id, state_id, value, request_id):
with self.__host._lock:
if self._instance(instance_id) is None:
return self._error(instance_id, "UNKNOWN_INSTANCE", request_id)
slots = export_intellixcap_s1_contract_metadata()["state_slots"]
if not self._visible(state_id) or slots[state_id]["access"] != "read_write":
return self._error(instance_id, "ACCESS_DENIED", request_id)
via = slots[state_id]["write_via"]
return self.invoke(instance_id=instance_id, capability_id=via["capability_id"], arguments={via["argument"]: value}, request_id=request_id)
def _owned_operation(self, operation_id):
op = self.__host._operations.get(operation_id) if isinstance(operation_id, str) else None
return op if op is not None and op["principal_id"] == self.__principal_id and self._instance(op["instance_id"]) is not None else None
def _operation_response(self, op, request_id=None):
inst = self._instance(op["instance_id"])
result = op["result"] if op["status"] in ("succeeded", "failed", "cancelled") else self.__host._progress(inst)
error = None if op["status"] != "failed" else {"code": "HOST_REPORTED_FAILURE", "message": "Host reported thread-operation failure; motion and external effects were not rolled back.", "retryable": False, "side_effects": "partial", "progress": _ixs_copy.deepcopy(result)}
return self._envelope(op["instance_id"], request_id or op["request_id"], status=op["status"], operation_id=op["operation_id"], result=result, error=error)
def poll(self, *, operation_id):
with self.__host._lock:
op = self._owned_operation(operation_id)
return self._operation_response(op) if op is not None else self._error(None, "ACCESS_DENIED")
def cancel(self, *, operation_id, request_id):
with self.__host._lock:
op = self._owned_operation(operation_id)
if op is None:
return self._error(None, "ACCESS_DENIED", request_id)
return self._cached(op["instance_id"], request_id, ["cancel", operation_id], lambda: self._cancel(op, request_id))
def _cancel(self, op, request_id):
if op["status"] in ("succeeded", "failed", "cancelled"):
return self._operation_response(op, request_id)
inst = self._instance(op["instance_id"])
op.update({"phase": "cancelled", "status": "cancelled"})
inst["active_operation_id"] = None
s = _ixs_copy.deepcopy(inst["values"])
s["cycle.status"] = "cancelled"
self.__host._commit(inst, s)
op["result"] = self.__host._progress(inst)
# Invalidate unfulfilled attach requests: late acknowledgements may not attach.
if op["pending_event_id"]:
event = next(e for e in inst["events"] if e["event_id"] == op["pending_event_id"])
event["cancelled"] = True
op["pending_event_id"] = None
if s["attachment.constraint_id"] is not None:
self.__host._event(inst, op, "release", self.__host.time_s)
return self._operation_response(op, request_id)
# END CHEM-177 INTELLIXCAP S1 APPEND-ONLY RUNTIME
# BEGIN CHEM-176 AZENTA AUTOMATED ROLL HEAT SEALER APPEND-ONLY RUNTIME
import copy as _ahs_copy
import json as _ahs_json
import math as _ahs_math
import threading as _ahs_threading
AZENTA_HEAT_SEALER_TYPE = 'instrument.azenta_automated_roll_heat_sealer_a4s'
AZENTA_HEAT_SEALER_Q_MAX_M = .074
def _ahs_number(value):
try:
return type(value) in (int, float) and _ahs_math.isfinite(value)
except (TypeError, OverflowError):
return False
def _ahs_string(value):
return isinstance(value, str) and bool(value.strip())
def _ahs_obj(properties):
return {'type': 'object', 'properties': properties, 'required': list(properties), 'additionalProperties': False}
def _ahs_num(unit, lo=0, hi=None, integer=False):
s = {'type': 'integer' if integer else 'number', 'minimum': lo, 'x-unit': unit}
if hi is not None:
s['maximum'] = hi
return s
def _ahs_nullable(schema):
return {'anyOf': [schema, {'type': 'null'}]}
def _ahs_slot(schema, unit, origin, visibility='agent', via=None):
return {'value_schema': schema, 'unit': unit, 'origin': origin, 'visibility': visibility,
'access': 'read_write' if via else 'read_only', 'reference_conditions': None,
'write_via': {'capability_id': via[0], 'parameter': via[1], 'fixed_arguments': {}} if via else None,
'sampling': {'mode': 'instant', 'time_domain': 'simulation', 'window': None}}
_AHS_STR = {'type': 'string'}
_AHS_BOOL = {'type': 'boolean'}
_AHS_TEMP = _ahs_num('K', 373.15, 468.15)
_AHS_DURATION = _ahs_num('s', .1, 10)
_AHS_Q = _ahs_num('m', 0, AZENTA_HEAT_SEALER_Q_MAX_M)
_AHS_STATUS = {'type': 'string', 'enum': ['idle', 'running', 'succeeded', 'cancelled', 'failed']}
_AHS_SLOTS = {
'power.enabled': _ahs_slot(_AHS_BOOL, '1', 'setpoint', via=('power.set', 'enabled')),
'thermal.setpoint_K': _ahs_slot(_ahs_nullable(_AHS_TEMP), 'K', 'setpoint', via=('thermal.set_temperature', 'temperature_K')),
'measurement.temperature_K': _ahs_slot(_ahs_nullable(_ahs_num('K')), 'K', 'derived'),
'thermal.target_reached': _ahs_slot(_AHS_BOOL, '1', 'derived'),
'simulation.thermal_rate_configured': _ahs_slot(_AHS_BOOL, '1', 'derived'),
'configuration.press_time_s': _ahs_slot(_ahs_nullable(_AHS_DURATION), 's', 'setpoint'),
'configuration.plate_adapter_id': _ahs_slot(_ahs_nullable(_AHS_STR), '1', 'setpoint'),
'configuration.film_roll_position_id': _ahs_slot(_ahs_nullable(_AHS_STR), '1', 'setpoint'),
'plate.loaded': _ahs_slot(_AHS_BOOL, '1', 'scene'),
'plate.plate_id': _ahs_slot(_ahs_nullable(_AHS_STR), '1', 'scene'),
'plate.height_m': _ahs_slot(_ahs_nullable(_ahs_num('m', .003, .060)), 'm', 'scene'),
'plate.attachment_constraint_id': _ahs_slot(_ahs_nullable(_AHS_STR), '1', 'scene'),
'plate.simulated_sealed': _ahs_slot(_AHS_BOOL, '1', 'derived'),
'film.roll_id': _ahs_slot(_ahs_nullable(_AHS_STR), '1', 'scene'),
'film.width_m': _ahs_slot(_ahs_nullable(_ahs_num('m', .075, .085)), 'm', 'scene'),
'film.remaining_seals': _ahs_slot(_ahs_nullable(_ahs_num('1', 0, 5000, True)), '1', 'derived'),
'scene.press_displacement_m': _ahs_slot(_AHS_Q, 'm', 'scene', via=('scene.set_press_displacement', 'displacement_m')),
'sealing.status': _ahs_slot(_AHS_STATUS, '1', 'derived'),
'sealing.elapsed_s': _ahs_slot(_ahs_num('s', 0, 10), 's', 'derived'),
'sealing.progress': _ahs_slot(_ahs_num('1', 0, 1), '1', 'derived'),
'truth.temperature_K': _ahs_slot(_ahs_nullable(_ahs_num('K')), 'K', 'process_truth', 'debug'),
'truth.thermal_rate_K_s': _ahs_slot(_ahs_nullable(_ahs_num('K/s')), 'K/s', 'process_truth', 'debug'),
}
_AHS_OPERATION = _ahs_obj({'operation_id': _AHS_STR, 'status': _AHS_STATUS, 'elapsed_s': _ahs_num('s', 0, 10),
'progress': _ahs_num('1', 0, 1), 'simulated_sealed': _AHS_BOOL})
_AHS_READ_IDS = ['measurement.temperature_K', 'thermal.target_reached', 'film.remaining_seals', 'plate.simulated_sealed', 'sealing.status', 'sealing.elapsed_s', 'sealing.progress']
_AHS_COMPONENTS = {'power.set': ['power_data_panel'], 'thermal.set_temperature': ['press_head'],
'configuration.set': ['plate_adapter', 'roll_support'], 'scene.set_press_displacement': ['press_head', 'guide_rails'],
'sealing.start': ['press_head', 'film_path', 'external_plate'], 'sealing.poll': ['status_display'],
'sealing.cancel': ['press_head'], 'sealing.read': ['status_display'], 'sealing.set_pressure': ['press_head']}
_AHS_LIMITATIONS = [
'温度100–195°C、时间0.1–10s、板高3–60mm、膜宽75–85mm来自CHEM-176三表；SI接口采用K、s、m。',
'热初始值和热速率没有缺省值；温度推进只采用宿主明确给定且附证据的线性接近设定值模型，无热容、功率、冷却曲线或PID推断。',
'measurement.temperature_K为理想化过程代理且quality=estimated；target_reached只比较模型目标，不是实测稳定性或厂家互锁。±1K均匀性只作为规格，不作为目标公差。',
'压合q=0..0.074m、压头底z=.105-q、板顶z=.028+height和接触q=.077-height均是几何假设，非厂家行程或接触力学。',
'一卷最多5000次是上限；宿主须提供实际剩余次数，默认null。每次已接受封膜消耗1次膜配额；取消或失败不退回膜。未推断膜长度或实际进给距离。',
'film_roll_position_id与plate_adapter_id引用宿主装载的兼容配置；真实位置坐标和厂家适配器枚举未知，不生成任意假坐标。',
'simulated_sealed仅表示配置、温度代理、压合接触与持续时间条件满足，不预测粘接强度、泄漏、耐溶剂性或真实密封质量。压力不可任意编程且未建模。',
'scene_adapter与attach/release需宿主True确认；robot与hardware absent，未实现接触抓取、力控制或实际输送。',
'去重仅当前宿主内存有效；API身份过滤不是Python、文件系统或进程安全隔离。取消保留已经消耗时间、膜与压头位置。',
]
def export_azenta_heat_sealer_contract_metadata():
slots = _ahs_copy.deepcopy(_AHS_SLOTS)
for sid, slot in slots.items():
slot['read_binding'] = 'AzentaHeatSealerSession.read(instance_id=..., state_ids=[%r])' % sid
slots['scene.press_displacement_m']['reference_conditions'] = 'q positive down; ahs__press_joint.location.z=-q; 0..0.074m geometric assumption'
specs = {
'power.set': ({'enabled': _AHS_BOOL}, _ahs_obj({'enabled': _AHS_BOOL}), {'enabled': True}, ['power.enabled', 'thermal.target_reached', 'measurement.temperature_K', 'sealing.status'], 'device_command', '设置仿真供电；断电取消封膜并保留压头、时间和已消耗膜。'),
'thermal.set_temperature': ({'temperature_K': _AHS_TEMP}, _ahs_obj({'setpoint_K': _AHS_TEMP}), {'temperature_K': 423.15}, ['thermal.setpoint_K', 'thermal.target_reached'], 'device_command', '写入封膜温度目标；只在宿主推进时才更新已配置的温度过程。'),
'configuration.set': ({'press_time_s': _AHS_DURATION, 'plate_adapter_id': _AHS_STR, 'film_roll_position_id': _AHS_STR}, _ahs_obj({'press_time_s': _AHS_DURATION, 'plate_adapter_id': _AHS_STR, 'film_roll_position_id': _AHS_STR}), {'press_time_s': 1.0, 'plate_adapter_id': 'host_adapter', 'film_roll_position_id': 'host_roll_position'}, ['configuration.press_time_s', 'configuration.plate_adapter_id', 'configuration.film_roll_position_id'], 'configuration', '选择时间和宿主已装载的板适配器、膜卷位置标识。'),
'scene.set_press_displacement': ({'displacement_m': _AHS_Q}, _ahs_obj({'displacement_m': _AHS_Q}), {'displacement_m': .017}, ['scene.press_displacement_m'], 'configuration', '宿主确认压合展示关节；装板时不能穿过几何接触平面。'),
'sealing.start': ({}, _AHS_OPERATION, {}, ['sealing.status', 'sealing.elapsed_s', 'sealing.progress', 'plate.simulated_sealed', 'film.remaining_seals'], 'device_command', '开始计时封膜，立即消耗1次膜配额；accepted不表示密封完成。'),
'sealing.poll': ({'operation_id': _AHS_STR}, _AHS_OPERATION, {'operation_id': 'seal_demo_1'}, [], 'query', '读取当前身份拥有的任务进度，不推进宿主时钟。'),
'sealing.cancel': ({'operation_id': _AHS_STR}, _AHS_OPERATION, {'operation_id': 'seal_demo_1'}, ['sealing.status'], 'device_command', '取消运行，保留时间、膜消耗和压合位置。'),
'sealing.read': ({}, _ahs_obj({k: slots[k]['value_schema'] for k in _AHS_READ_IDS}), {}, [], 'query', '读取估计温度、膜余量和当前封膜状态，不推进时间。'),
'sealing.set_pressure': ({}, _ahs_obj({}), {}, [], 'device_command', '压力并非任意可编程；没有压力设置实现或虚构参数。'),
}
prereq = {'power.set': [], 'thermal.set_temperature': ['已上电且没有正在封膜操作。'],
'configuration.set': ['已上电；无正在封膜操作；板和膜已由宿主装载，两个配置ID匹配。'],
'scene.set_press_displacement': ['无正在封膜操作；场景回调绑定并返回True；q不得穿透已装板的接触平面。'],
'sealing.start': ['已上电；已装板与兼容膜；配置完整匹配；膜余量>0；未封膜；温度代理达到目标；场景回调已确认接触q。'],
'sealing.poll': ['操作属于当前实例与宿主登记身份。'], 'sealing.cancel': ['操作属于当前实例与宿主登记身份。'],
'sealing.read': [], 'sealing.set_pressure': []}
caps = {}
for cid, (props, out, example, effects, kind, desc) in specs.items():
entries = [{'state_id': k, 'timing': 'immediate', 'description_zh': '本调用成功后的明确状态更新。'} for k in effects]
if cid == 'thermal.set_temperature':
entries += [{'state_id': k, 'timing': 'on_step', 'description_zh': '仅宿主已给出初值、线性热速率及证据时，随共同时间更新。'} for k in ['truth.temperature_K', 'measurement.temperature_K', 'thermal.target_reached']]
if cid == 'sealing.start':
entries += [{'state_id': k, 'timing': 'on_step', 'description_zh': '只由宿主共同时间推进；满设定持续时间后改变模拟密封状态。'} for k in ['sealing.status', 'sealing.elapsed_s', 'sealing.progress', 'plate.simulated_sealed']]
unsupported = cid == 'sealing.set_pressure'
scene = cid == 'scene.set_press_displacement'
observes = _AHS_READ_IDS if cid == 'sealing.read' else ['sealing.status', 'sealing.elapsed_s', 'sealing.progress', 'plate.simulated_sealed'] if cid.startswith('sealing.') and not unsupported else [k for k in effects if slots[k]['visibility'] == 'agent']
caps[cid] = {'name_zh': desc, 'description_zh': desc, 'kind': kind, 'visibility': 'agent', 'availability': 'unsupported' if unsupported else 'implemented',
'component_ids': _AHS_COMPONENTS[cid], 'input_schema': _ahs_obj(_ahs_copy.deepcopy(props)), 'output_schema': _ahs_copy.deepcopy(out),
'state_effects': entries, 'observes': observes, 'example_arguments': [_ahs_copy.deepcopy(example)], 'preconditions_zh': prereq[cid],
'binding': None if unsupported else 'basic40_runtime_automation.AzentaHeatSealerSession.invoke(instance_id=..., capability_id=%r, arguments=..., request_id=...)' % cid,
'implementation': {'process': 'absent' if unsupported else 'not_applicable' if scene else 'implemented', 'scene': 'implemented' if scene else 'not_applicable', 'robot': 'absent', 'hardware': 'absent', 'host': 'absent' if unsupported else 'implemented'},
'model_effects': {'mode': 'host_required' if scene else 'none', 'binding_ids': [], 'description_zh': 'scene_adapter(instance_id, {scene.press_displacement_m:q})须返回True；没有回调不返回成功。' if scene else '只更新设置、观测与封膜逻辑，压头保留当前姿态，无附加可见动作。'},
'execution_notes': {'mode': 'asynchronous' if cid == 'sealing.start' else 'synchronous', 'time_domain': 'simulation', 'completion_zh': '宿主累计时间达到设定时间并持续满足模型温度与接触条件。' if cid == 'sealing.start' else '返回succeeded表示本次调用完成。', 'cancellable': cid == 'sealing.start', 'partial_failure_zh': '取消保留压头位置、已用时间及1次膜消耗，未完成板不标密封；外部场景失败可能有未知副作用。', 'retry_zh': '相同request_id与参数使用当前内存缓存；参数冲突拒绝；不保证跨重启。'},
'errors': [{'code': c, 'description_zh': d, 'side_effects': side} for c, d, side in [
('INVALID_ARGUMENT', '类型、范围或额外字段无效。', 'none'), ('UNKNOWN_INSTANCE', '实例未知或不在身份范围。', 'none'),
('UNKNOWN_CAPABILITY', '能力未知。', 'none'), ('PRECONDITION_FAILED', '供电、装载、温度、接触或配置条件未满足。', 'none'),
('BUSY', '封膜操作占用资源。', 'none'), ('REQUEST_CONFLICT', '请求ID用于不同参数。', 'none'),
('UNSUPPORTED', '能力不支持或场景未绑定。', 'none'), ('DEVICE_ERROR', '外部回调未确认，内部未提交。', 'unknown'),
('UNKNOWN_OPERATION', '任务不属于当前实例和身份。', 'none')]]}
return {'asset_type_id': AZENTA_HEAT_SEALER_TYPE, 'asset_version': '1.0.1', 'catalog_id': 'CHEM-176', 'state_slots': slots, 'capabilities': caps,
'parameters': {k: {'value': v, 'unit': u, 'evidence': e} for k, v, u, e in [
('temperature_range_K', [373.15, 468.15], 'K', 'catalog'), ('press_time_range_s', [.1, 10], 's', 'catalog'),
('plate_height_range_m', [.003, .060], 'm', 'catalog'), ('film_width_range_m', [.075, .085], 'm', 'catalog'),
('block_temperature_uniformity_K', 1.0, 'K', 'catalog'), ('maximum_seals_per_roll', 5000, '1', 'catalog'),
('body_mass_without_roll_kg', 27.0, 'kg', 'catalog'), ('body_dimensions_xyz_m', [.230, .507, .276], 'm', 'catalog'),
('press_display_travel_m', .074, 'm', 'assumed'), ('thermal_rate_K_s', None, 'K/s', 'unknown'),
('press_pressure_Pa', None, 'Pa', 'unknown'), ('seal_strength_Pa', None, 'Pa', 'unknown'),
('leak_rate_m3_s', None, 'm^3/s', 'unknown'), ('roll_position_m', None, 'm', 'unknown')]},
'host_api': {k: {'entrypoint': 'AzentaHeatSealerRuntime.' + k, 'description_zh': v} for k, v in {
'create_instance': '独立实例与可选scene_adapter；温度和膜余量初始null。', 'register_principal': '可信宿主注册身份与实例范围。',
'host_load_plate': '显式板ID、板高、适配器ID及兼容证据；要求压头q=0、无旧板。',
'host_unload_plate': '宿主确认外部移出；要求压头q=0、无附着、无运行任务，不产生机械位移。',
'host_load_film': '显式膜卷ID、宽、剩余次数、位置ID与兼容证据；上限5000，不默认满卷。',
'host_set_temperature': '宿主给出温度与证据，得到estimated代理；封膜中偏離目标使任务失败并保留部分效果。',
'host_configure_thermal_rate': '显式正有限线性热速率与证据，无默认系数；不允许封膜中更改。',
'host_step': 'host_step(dt_s,world_time_s=...)正有限步长且与共同世界时间一致；read不推进。',
'host_attach': 'attach事件含plate_id及constraint_id；宿主attachment_adapter返回True才登记，无接触抓取。',
'host_release': 'release事件含plate_id及constraint_id；宿主True确认后清除约束，保留板和姿态。'}.items()},
'limitations': list(_AHS_LIMITATIONS), 'output_schema_scope': 'capability output_schema validates response.result; truth.* never appears in agent values'}
class AzentaHeatSealerRuntime:
"""Trusted host. Expose only an authenticated session to an agent."""
def __init__(self):
self.time_s, self._next_operation = 0.0, 1
self._instances, self._principals, self._requests, self._operations = {}, {}, {}, {}
self._lock = _ahs_threading.RLock()
def create_instance(self, instance_id, scene_adapter=None):
with self._lock:
if not _ahs_string(instance_id) or instance_id in self._instances or (scene_adapter is not None and not callable(scene_adapter)):
raise ValueError('Unique instance ID and optional callable scene adapter required')
state = {sid: None for sid in _AHS_SLOTS}
state.update({'power.enabled': False, 'thermal.target_reached': False, 'simulation.thermal_rate_configured': False,
'plate.loaded': False, 'plate.simulated_sealed': False, 'scene.press_displacement_m': 0.0,
'sealing.status': 'idle', 'sealing.elapsed_s': 0.0, 'sealing.progress': 0.0})
self._instances[instance_id] = {'state': state, 'revision': 0, 'adapter': scene_adapter, 'scene_confirmed': False,
'active_operation': None, 'plate_adapter_id': None, 'film_position_id': None, 'evidence': {}}
def register_principal(self, principal_id, *, visibility, instance_ids=None):
with self._lock:
if not _ahs_string(principal_id) or principal_id in self._principals or visibility not in ('agent', 'debug', 'evaluator'):
raise ValueError('Host-assigned unique identity with valid visibility required')
if instance_ids is not None and (not isinstance(instance_ids, (list, tuple, set, frozenset)) or any(not isinstance(k, str) or k not in self._instances for k in instance_ids)):
raise ValueError('Invalid instance scope')
self._principals[principal_id] = (visibility, None if instance_ids is None else frozenset(instance_ids))
def session(self, principal_id):
if not isinstance(principal_id, str) or principal_id not in self._principals:
raise ValueError('Host registration required')
return AzentaHeatSealerSession(self, principal_id)
def _get(self, iid, principal=None):
if not isinstance(iid, str) or iid not in self._instances:
return None
if principal is not None:
p = self._principals.get(principal)
if p is None or (p[1] is not None and iid not in p[1]):
return None
return self._instances[iid]
def _require_idle(self, iid, retracted=False):
item = self._get(iid)
if item is None or item['state']['sealing.status'] == 'running' or (retracted and item['state']['scene.press_displacement_m'] != 0):
raise ValueError('Known idle instance with required press position needed')
return item
@staticmethod
def _refresh(s):
s['measurement.temperature_K'] = s['truth.temperature_K'] if s['power.enabled'] else None
s['thermal.target_reached'] = bool(s['power.enabled'] and s['truth.temperature_K'] is not None and s['thermal.setpoint_K'] is not None and _ahs_math.isclose(s['truth.temperature_K'], s['thermal.setpoint_K'], rel_tol=0, abs_tol=1e-9))
def _stop(self, item, status):
s = item['state']
if s['sealing.status'] == 'running':
s['sealing.status'] = status
self._operations[item['active_operation']]['status'] = status
def host_load_plate(self, instance_id, *, plate_id, height_m, plate_adapter_id, compatibility_evidence):
with self._lock:
item = self._require_idle(instance_id, True)
s = item['state']
if s['plate.loaded'] or not all(_ahs_string(x) for x in (plate_id, plate_adapter_id, compatibility_evidence)) or not _ahs_number(height_m) or not .003 <= height_m <= .060:
raise ValueError('Empty carrier, explicit compatible IDs and plate height .003..060m required')
s.update({'plate.loaded': True, 'plate.plate_id': plate_id, 'plate.height_m': float(height_m), 'plate.simulated_sealed': False,
'sealing.status': 'idle', 'sealing.elapsed_s': 0.0, 'sealing.progress': 0.0})
item['plate_adapter_id'], item['active_operation'] = plate_adapter_id, None
item['evidence']['plate'] = compatibility_evidence
item['revision'] += 1
def host_unload_plate(self, instance_id):
with self._lock:
item = self._require_idle(instance_id, True)
s = item['state']
if not s['plate.loaded'] or s['plate.attachment_constraint_id'] is not None:
raise ValueError('Loaded unattached plate required')
s.update({'plate.loaded': False, 'plate.plate_id': None, 'plate.height_m': None, 'plate.simulated_sealed': False})
item['plate_adapter_id'] = None
item['revision'] += 1
def host_load_film(self, instance_id, *, roll_id, width_m, remaining_seals, film_roll_position_id, compatibility_evidence):
with self._lock:
item = self._require_idle(instance_id, True)
if not all(_ahs_string(x) for x in (roll_id, film_roll_position_id, compatibility_evidence)) or not _ahs_number(width_m) or not .075 <= width_m <= .085 or type(remaining_seals) is not int or not 0 <= remaining_seals <= 5000:
raise ValueError('Compatible film IDs, width .075..085m and explicit remaining count 0..5000 required')
item['state'].update({'film.roll_id': roll_id, 'film.width_m': float(width_m), 'film.remaining_seals': remaining_seals})
item['film_position_id'] = film_roll_position_id
item['evidence']['film'] = compatibility_evidence
item['revision'] += 1
def host_set_temperature(self, instance_id, *, temperature_K, evidence):
with self._lock:
item = self._get(instance_id)
if item is None or not _ahs_number(temperature_K) or temperature_K <= 0 or not _ahs_string(evidence):
raise ValueError('Positive finite host temperature and evidence required')
item['state']['truth.temperature_K'] = float(temperature_K)
item['evidence']['temperature'] = evidence
self._refresh(item['state'])
if not item['state']['thermal.target_reached']:
self._stop(item, 'failed')
item['revision'] += 1
def host_configure_thermal_rate(self, instance_id, *, thermal_rate_K_s, evidence):
with self._lock:
item = self._require_idle(instance_id)
if not _ahs_number(thermal_rate_K_s) or thermal_rate_K_s <= 0 or not _ahs_string(evidence):
raise ValueError('Positive finite explicit linear thermal rate and evidence required')
item['state'].update({'truth.thermal_rate_K_s': float(thermal_rate_K_s), 'simulation.thermal_rate_configured': True})
item['evidence']['thermal_rate'] = evidence
item['revision'] += 1
def _attachment(self, instance_id, event_name, constraint_id, callback):
with self._lock:
item = self._require_idle(instance_id, True)
s = item['state']
if not s['plate.loaded'] or not callable(callback) or (event_name == 'attach' and (not _ahs_string(constraint_id) or s['plate.attachment_constraint_id'] is not None)) or (event_name == 'release' and s['plate.attachment_constraint_id'] is None):
raise ValueError('Valid loaded plate, constraint and host callback required')
event = {'event': event_name, 'plate_id': s['plate.plate_id'], 'constraint_id': constraint_id if event_name == 'attach' else s['plate.attachment_constraint_id']}
try:
confirmed = callback(instance_id, _ahs_copy.deepcopy(event)) is True
except Exception:
confirmed = False
if not confirmed:
raise RuntimeError('Host attachment callback did not confirm; external effect may be unknown')
s['plate.attachment_constraint_id'] = constraint_id if event_name == 'attach' else None
item['revision'] += 1
return event
def host_attach(self, instance_id, *, constraint_id, attachment_adapter):
return self._attachment(instance_id, 'attach', constraint_id, attachment_adapter)
def host_release(self, instance_id, *, attachment_adapter):
return self._attachment(instance_id, 'release', None, attachment_adapter)
def host_step(self, dt_s, *, world_time_s):
with self._lock:
if not _ahs_number(dt_s) or dt_s <= 0 or not _ahs_number(world_time_s) or not _ahs_number(self.time_s + dt_s) or not _ahs_math.isclose(world_time_s, self.time_s + dt_s, rel_tol=0, abs_tol=1e-9) or world_time_s <= self.time_s:
raise ValueError('Positive finite dt and matching monotonic common world time required')
for item in self._instances.values():
s = item['state']
before = _ahs_copy.deepcopy(s)
temp, target, rate = s['truth.temperature_K'], s['thermal.setpoint_K'], s['truth.thermal_rate_K_s']
if s['power.enabled'] and temp is not None and target is not None and rate is not None:
# Clamp before multiplication so even a huge finite rate cannot overflow.
span = abs(target - temp)
change = span if dt_s >= span / rate else dt_s * rate
s['truth.temperature_K'] = target if change >= span else temp + _ahs_math.copysign(change, target - temp)
self._refresh(s)
if s['sealing.status'] == 'running':
op = self._operations[item['active_operation']]
if not s['thermal.target_reached']:
self._stop(item, 'failed')
else:
elapsed = min(op['duration_s'], op['elapsed_s'] + dt_s)
op['elapsed_s'] = elapsed
s['sealing.elapsed_s'], s['sealing.progress'] = elapsed, elapsed / op['duration_s']
if elapsed >= op['duration_s']:
s['sealing.status'], s['plate.simulated_sealed'] = 'succeeded', True
op['status'], op['simulated_sealed'] = 'succeeded', True
if s != before:
item['revision'] += 1
self.time_s = float(world_time_s)
return {'time_s': self.time_s}
def debug_snapshot(self):
with self._lock:
return _ahs_copy.deepcopy({'time_s': self.time_s, 'instances': {i: {k: v for k, v in item.items() if k != 'adapter'} for i, item in self._instances.items()}, 'operations': self._operations})
def _response(self, iid, request_id=None, *, status='succeeded', result=None, operation_id=None, code=None, side_effects='none'):
item = self._get(iid)
return {'protocol_version': '1.0.0', 'instance_id': iid, 'request_id': request_id, 'operation_id': operation_id,
'status': status, 'state_revision': None if item is None or code == 'UNKNOWN_INSTANCE' else item['revision'], 'clock': {'domain': 'simulation', 'time_s': self.time_s},
'result': _ahs_copy.deepcopy(result), 'observations': {}, 'error': None if code is None else {'code': code,
'message': 'Operation could not be completed: ' + code, 'retryable': False, 'side_effects': side_effects, 'known_progress': None}}
@staticmethod
def _operation_result(op):
return {'operation_id': op['id'], 'status': op['status'], 'elapsed_s': op['elapsed_s'],
'progress': op['elapsed_s'] / op['duration_s'], 'simulated_sealed': op['simulated_sealed']}
def _invoke(self, principal, iid, cid, args, request_id):
with self._lock:
reject = lambda code, status='rejected', side='none': self._response(iid, request_id, status=status, code=code, side_effects=side)
item = self._get(iid, principal)
if item is None:
return reject('UNKNOWN_INSTANCE')
if not isinstance(cid, str) or cid not in _AHS_COMPONENTS:
return reject('UNKNOWN_CAPABILITY')
if not _ahs_string(request_id) or not isinstance(args, dict):
return reject('INVALID_ARGUMENT')
try:
fingerprint = _ahs_json.dumps([cid, args], sort_keys=True, allow_nan=False, separators=(',', ':'))
except (TypeError, ValueError, OverflowError):
return reject('INVALID_ARGUMENT')
key = (principal, iid, request_id)
if key in self._requests:
old, response = self._requests[key]
return _ahs_copy.deepcopy(response) if old == fingerprint else reject('REQUEST_CONFLICT')
def reject(code, status='rejected', side='none'):
response = self._response(iid, request_id, status=status, code=code, side_effects=side)
self._requests[key] = (fingerprint, _ahs_copy.deepcopy(response))
return response
fields = {'power.set': ['enabled'], 'thermal.set_temperature': ['temperature_K'],
'configuration.set': ['press_time_s', 'plate_adapter_id', 'film_roll_position_id'], 'scene.set_press_displacement': ['displacement_m'],
'sealing.start': [], 'sealing.poll': ['operation_id'], 'sealing.cancel': ['operation_id'], 'sealing.read': [], 'sealing.set_pressure': []}[cid]
valid = set(args) == set(fields)
if valid and cid == 'power.set': valid = type(args['enabled']) is bool
if valid and cid == 'thermal.set_temperature': valid = _ahs_number(args['temperature_K']) and 373.15 <= args['temperature_K'] <= 468.15
if valid and cid == 'configuration.set': valid = _ahs_number(args['press_time_s']) and .1 <= args['press_time_s'] <= 10 and _ahs_string(args['plate_adapter_id']) and _ahs_string(args['film_roll_position_id'])
if valid and cid == 'scene.set_press_displacement': valid = _ahs_number(args['displacement_m']) and 0 <= args['displacement_m'] <= AZENTA_HEAT_SEALER_Q_MAX_M
if valid and cid in ('sealing.poll', 'sealing.cancel'): valid = _ahs_string(args['operation_id'])
if not valid:
return reject('INVALID_ARGUMENT')
if cid == 'sealing.set_pressure':
return reject('UNSUPPORTED', 'unsupported')
s = item['state']
if cid in ('thermal.set_temperature', 'configuration.set', 'sealing.start') and not s['power.enabled']:
return reject('PRECONDITION_FAILED')
if cid in ('thermal.set_temperature', 'configuration.set', 'scene.set_press_displacement', 'sealing.start') and s['sealing.status'] == 'running':
return reject('BUSY')
if cid == 'configuration.set' and (not s['plate.loaded'] or s['film.roll_id'] is None or args['plate_adapter_id'] != item['plate_adapter_id'] or args['film_roll_position_id'] != item['film_position_id']):
return reject('PRECONDITION_FAILED')
if cid == 'scene.set_press_displacement' and s['plate.loaded'] and args['displacement_m'] > .077 - s['plate.height_m'] + 1e-12:
return reject('PRECONDITION_FAILED')
if cid == 'sealing.start' and (not s['plate.loaded'] or s['plate.simulated_sealed'] or s['film.remaining_seals'] is None or s['film.remaining_seals'] < 1 or s['configuration.press_time_s'] is None or s['configuration.plate_adapter_id'] != item['plate_adapter_id'] or s['configuration.film_roll_position_id'] != item['film_position_id'] or not s['thermal.target_reached'] or not item['scene_confirmed'] or not _ahs_math.isclose(s['scene.press_displacement_m'], .077 - s['plate.height_m'], rel_tol=0, abs_tol=1e-9)):
return reject('PRECONDITION_FAILED')
op = None
if cid in ('sealing.poll', 'sealing.cancel'):
op = self._operations.get(args['operation_id'])
if op is None or op['instance_id'] != iid or op['principal'] != principal:
return reject('UNKNOWN_OPERATION')
if cid == 'scene.set_press_displacement':
if item['adapter'] is None:
return reject('UNSUPPORTED', 'unsupported')
try:
confirmed = item['adapter'](iid, {'scene.press_displacement_m': float(args['displacement_m'])}) is True
except Exception:
confirmed = False
if not confirmed:
response = reject('DEVICE_ERROR', 'failed', 'unknown')
self._requests[key] = (fingerprint, _ahs_copy.deepcopy(response))
return response
before = _ahs_copy.deepcopy(s)
status, op_id = 'succeeded', None
if cid == 'power.set':
s['power.enabled'] = args['enabled']
self._refresh(s)
if not args['enabled']:
self._stop(item, 'cancelled')
result = {'enabled': args['enabled']}
elif cid == 'thermal.set_temperature':
s['thermal.setpoint_K'] = float(args['temperature_K'])
self._refresh(s)
result = {'setpoint_K': s['thermal.setpoint_K']}
elif cid == 'configuration.set':
for k, v in args.items(): s['configuration.' + k] = v
result = args
elif cid == 'scene.set_press_displacement':
s['scene.press_displacement_m'] = float(args['displacement_m'])
item['scene_confirmed'] = True
result = {'displacement_m': s['scene.press_displacement_m']}
elif cid == 'sealing.start':
op_id = 'seal_%s_%d' % (iid, self._next_operation)
self._next_operation += 1
op = {'id': op_id, 'instance_id': iid, 'principal': principal, 'plate_id': s['plate.plate_id'], 'duration_s': s['configuration.press_time_s'],
'status': 'running', 'elapsed_s': 0.0, 'simulated_sealed': False}
self._operations[op_id], item['active_operation'] = op, op_id
s.update({'sealing.status': 'running', 'sealing.elapsed_s': 0.0, 'sealing.progress': 0.0, 'plate.simulated_sealed': False})
s['film.remaining_seals'] -= 1
status, result = 'accepted', self._operation_result(op)
elif cid in ('sealing.poll', 'sealing.cancel'):
op_id = op['id']
if cid == 'sealing.cancel' and op['status'] == 'running': self._stop(item, 'cancelled')
result = self._operation_result(op)
else:
result = {k: s[k] for k in _AHS_READ_IDS}
if s != before or cid == 'scene.set_press_displacement':
item['revision'] += 1
response = self._response(iid, request_id, status=status, result=result, operation_id=op_id)
self._requests[key] = (fingerprint, _ahs_copy.deepcopy(response))
return response
class AzentaHeatSealerSession:
"""Transport facade; identities and host temperature values are not caller parameters."""
def __init__(self, host, principal_id):
if not isinstance(principal_id, str) or principal_id not in host._principals:
raise ValueError('Host registration required')
self.__host, self.__principal = host, principal_id
def describe(self, *, asset_type_id=None, instance_id=None):
with self.__host._lock:
if (asset_type_id is None) == (instance_id is None):
raise ValueError('Exactly one type or instance ID required')
if (asset_type_id is not None and asset_type_id != AZENTA_HEAT_SEALER_TYPE) or (instance_id is not None and self.__host._get(instance_id, self.__principal) is None):
return self.__host._response(instance_id, status='rejected', code='UNKNOWN_INSTANCE')
m = export_azenta_heat_sealer_contract_metadata()
m.pop('host_api')
if self.__host._principals[self.__principal][0] == 'agent':
m['state_slots'] = {k: v for k, v in m['state_slots'].items() if v['visibility'] == 'agent'}
for cap in m['capabilities'].values():
cap['state_effects'] = [e for e in cap['state_effects'] if e['state_id'] in m['state_slots']]
m['instance_id'] = instance_id
if instance_id is not None and self.__host._instances[instance_id]['adapter'] is None:
m['capabilities']['scene.set_press_displacement']['availability'] = 'unsupported'
return m
def read(self, *, instance_id, state_ids=None):
with self.__host._lock:
h, item = self.__host, self.__host._get(instance_id, self.__principal)
if item is None:
return h._response(instance_id, status='rejected', code='UNKNOWN_INSTANCE')
allowed = {k for k, v in _AHS_SLOTS.items() if h._principals[self.__principal][0] != 'agent' or v['visibility'] == 'agent'}
if state_ids is None:
state_ids = sorted(allowed)
if not isinstance(state_ids, list) or any(not isinstance(k, str) or k not in allowed for k in state_ids):
return h._response(instance_id, status='rejected', code='ACCESS_DENIED')
r = h._response(instance_id)
for sid in state_ids:
val = _ahs_copy.deepcopy(item['state'][sid])
r['observations'][sid] = {'value': val, 'unit': _AHS_SLOTS[sid]['unit'], 'quality': 'unavailable' if val is None else 'estimated' if sid.startswith('measurement.') or sid in ('thermal.target_reached', 'plate.simulated_sealed') else 'valid', 'sample_time_s': h.time_s, 'sample_window_s': None}
if val is None:
r['observations'][sid]['unavailable_reason'] = 'not_configured_or_not_powered'
return r
def invoke(self, *, instance_id, capability_id, arguments, request_id):
return self.__host._invoke(self.__principal, instance_id, capability_id, arguments, request_id)
def write(self, *, instance_id, state_id, value, request_id):
with self.__host._lock:
if self.__host._get(instance_id, self.__principal) is None:
return self.__host._response(instance_id, request_id, status='rejected', code='UNKNOWN_INSTANCE')
slot = _AHS_SLOTS.get(state_id) if isinstance(state_id, str) else None
if slot is None or slot['write_via'] is None:
return self.__host._response(instance_id, request_id, status='rejected', code='ACCESS_DENIED')
via = slot['write_via']
return self.invoke(instance_id=instance_id, capability_id=via['capability_id'], arguments={via['parameter']: value}, request_id=request_id)
def poll(self, *, instance_id, operation_id):
with self.__host._lock:
h = self.__host
if h._get(instance_id, self.__principal) is None:
return h._response(instance_id, status='rejected', code='UNKNOWN_INSTANCE')
op = h._operations.get(operation_id) if isinstance(operation_id, str) else None
if op is None or op['instance_id'] != instance_id or op['principal'] != self.__principal:
return h._response(instance_id, status='rejected', code='UNKNOWN_OPERATION')
return h._response(instance_id, status=op['status'], result=h._operation_result(op), operation_id=operation_id)
def cancel(self, *, instance_id, operation_id, request_id):
return self.invoke(instance_id=instance_id, capability_id='sealing.cancel', arguments={'operation_id': operation_id}, request_id=request_id)
# END CHEM-176 AZENTA AUTOMATED ROLL HEAT SEALER APPEND-ONLY RUNTIME
# CHEM-176 discovery wording: the public schema explains filtering without naming private slots.
_ahs_export_metadata_v1 = export_azenta_heat_sealer_contract_metadata
def export_azenta_heat_sealer_contract_metadata():
metadata = _ahs_export_metadata_v1()
metadata['output_schema_scope'] = 'capability output_schema validates response.result; discovery contains no private instance values'
return metadata
# BEGIN CHEM-175 OPENTRONS FLEX APPEND-ONLY RUNTIME
"""CHEM-175 synthetic joint-state and volume-ledger adapter.
Host inventory registration is a simulation setup operation, not a measurement.
Give agents a Session over a transport boundary; Python name privacy is not a
sandbox and these APIs do not secure a shared host filesystem.
"""
import copy as _flex_copy
import json as _flex_json
import math as _flex_math
import threading as _flex_threading
OPENTRONS_FLEX_TYPE = 'instrument.opentrons_flex_single_5_1000ul'
OPENTRONS_FLEX_MIN_M3 = 5e-9
OPENTRONS_FLEX_MAX_M3 = 1e-6
OPENTRONS_FLEX_WORK_SLOTS = tuple('%s%d' % (row, col) for row in 'ABCD' for col in (1, 2, 3))
OPENTRONS_FLEX_STAGING_SLOTS = tuple(row + '4' for row in 'ABCD')
OPENTRONS_FLEX_ALL_SLOTS = OPENTRONS_FLEX_WORK_SLOTS + OPENTRONS_FLEX_STAGING_SLOTS
_FLEX_LIMITS = {'x_m': (-0.24, 0.24), 'y_m': (-0.21, 0.21), 'z_m': (0.0, 0.22)}
_FLEX_POSITION_NOTE = 'Joint coordinates in m: X right, Y rear, Z up; asset tip port = (x_m,y_m,0.26+z_m). Travel bounds and 1e-9 m target equality tolerance are simulation conventions, not manufacturer tolerances.'
def _flex_number(value):
try:
return type(value) in (int, float) and _flex_math.isfinite(value)
except (TypeError, ValueError, OverflowError):
return False
def _flex_id(value):
return isinstance(value, str) and bool(value.strip())
def _flex_obj(properties):
return {'type': 'object', 'properties': properties, 'required': list(properties), 'additionalProperties': False}
def _flex_num(unit, minimum=None, maximum=None):
result = {'type': 'number', 'x-unit': unit}
if minimum is not None:
result['minimum'] = minimum
if maximum is not None:
result['maximum'] = maximum
return result
_FLEX_POSITION_SCHEMA = _flex_obj({key: _flex_num('m', *limits) for key, limits in _FLEX_LIMITS.items()})
_FLEX_NULL_ID = {'anyOf': [{'type': 'string'}, {'type': 'null'}]}
_FLEX_CONTAINER_SCHEMA = _flex_obj({'container_id': {'type': 'string'}, 'slot_id': {'type': 'string', 'enum': list(OPENTRONS_FLEX_ALL_SLOTS)}, 'capacity_m3': _flex_num('m^3', 0), 'volume_m3': _flex_num('m^3', 0), 'position_m': _FLEX_POSITION_SCHEMA})
_FLEX_TIP_SCHEMA = _flex_obj({'tip_id': {'type': 'string'}, 'slot_id': _FLEX_NULL_ID, 'capacity_m3': _flex_num('m^3', OPENTRONS_FLEX_MIN_M3, OPENTRONS_FLEX_MAX_M3), 'volume_m3': _flex_num('m^3', 0), 'position_m': _FLEX_POSITION_SCHEMA})
_FLEX_TRANSFER_SCHEMA = _flex_obj({'transaction_id': {'type': 'string'}, 'donor_id': {'type': 'string'}, 'receiver_id': {'type': 'string'}, 'volume_m3': _flex_num('m^3', OPENTRONS_FLEX_MIN_M3, OPENTRONS_FLEX_MAX_M3), 'unit': {'type': 'string', 'const': 'm^3'}, 'kind': {'type': 'string', 'enum': ['aspirate', 'dispense']}, 'time_s': _flex_num('s', 0)})
_FLEX_EVENT_SCHEMA = _flex_obj({'event': {'type': 'string', 'enum': ['attach', 'release']}, 'tip_id': {'type': 'string'}, 'slot_id': {'type': 'string', 'enum': list(OPENTRONS_FLEX_ALL_SLOTS)}, 'time_s': _flex_num('s', 0), 'constraint_authority': {'type': 'string', 'const': 'host'}})
def _flex_slot(schema, unit, origin='scene', visibility='agent', write_via=None):
return {'value_schema': _flex_copy.deepcopy(schema), 'unit': unit, 'origin': origin, 'visibility': visibility,
'access': 'read_write' if write_via else 'read_only', 'write_via': write_via,
'reference_conditions': _FLEX_POSITION_NOTE if unit == 'm' else None,
'sampling': {'mode': 'instant', 'time_domain': 'simulation', 'window': None}}
_FLEX_SLOTS = {
'power.enabled': _flex_slot({'type': 'boolean'}, '1', 'setpoint', write_via={'capability_id': 'power.set', 'parameter': 'enabled', 'fixed_arguments': {}}),
**{'motion.' + k: _flex_slot(_flex_num('m', *v), 'm') for k, v in _FLEX_LIMITS.items()},
'motion.scene_adapter_registered': _flex_slot({'type': 'boolean'}, '1', 'derived'),
'tip.attached_id': _flex_slot(_FLEX_NULL_ID, '1'),
'tip.last_slot_id': _flex_slot(_FLEX_NULL_ID, '1'),
'tip.events': _flex_slot({'type': 'array', 'items': _FLEX_EVENT_SCHEMA}, '1'),
'deck.work_slot_ids': _flex_slot({'type': 'array', 'items': {'type': 'string'}, 'minItems': 12, 'maxItems': 12}, '1'),
'deck.staging_slot_ids': _flex_slot({'type': 'array', 'items': {'type': 'string'}, 'minItems': 4, 'maxItems': 4}, '1'),
'sample.transfer_count': _flex_slot({'type': 'integer', 'minimum': 0, 'x-unit': '1'}, '1', 'derived'),
'truth.tip_volume_m3': _flex_slot({'anyOf': [_flex_num('m^3', 0, OPENTRONS_FLEX_MAX_M3), {'type': 'null'}]}, 'm^3', 'process_truth', 'debug'),
'truth.containers': _flex_slot({'type': 'array', 'items': _FLEX_CONTAINER_SCHEMA}, '1', 'process_truth', 'debug'),
'truth.tips': _flex_slot({'type': 'array', 'items': _FLEX_TIP_SCHEMA}, '1', 'process_truth', 'debug'),
'truth.transfers': _flex_slot({'type': 'array', 'items': _FLEX_TRANSFER_SCHEMA}, '1', 'process_truth', 'debug'),
}
_FLEX_PUBLIC = tuple(k for k, v in _FLEX_SLOTS.items() if v['visibility'] == 'agent')
_FLEX_ARGUMENTS = {
'power.set': _flex_obj({'enabled': {'type': 'boolean'}}),
'motion.move': _flex_copy.deepcopy(_FLEX_POSITION_SCHEMA),
'sample.aspirate': _flex_obj({'container_id': {'type': 'string'}, 'volume_m3': _flex_num('m^3', OPENTRONS_FLEX_MIN_M3, OPENTRONS_FLEX_MAX_M3)}),
'sample.dispense': _flex_obj({'container_id': {'type': 'string'}, 'volume_m3': _flex_num('m^3', OPENTRONS_FLEX_MIN_M3, OPENTRONS_FLEX_MAX_M3)}),
'tip.attach': _flex_obj({'tip_id': {'type': 'string'}}),
'tip.release': _flex_obj({'target_slot_id': {'type': 'string', 'enum': list(OPENTRONS_FLEX_ALL_SLOTS)}}),
'state.read': _flex_obj({}),
'velocity.set': _flex_obj({}), 'sample.mix': _flex_obj({}), 'liquid_level.detect': _flex_obj({}),
}
_FLEX_UNSUPPORTED = frozenset(('velocity.set', 'sample.mix', 'liquid_level.detect'))
_FLEX_LIMITATIONS = [
'单通道5–1000 µL移液配置，12个工作位及4个暂存位；未配置夹爪，不实现接触抓取、机械拾头或硬件驱动。',
'吸排为等体积转移账本；不求解流速、黏度、弯月面、液面、湿润、吹出、残留、压缩性、组分混合、液滴或移液精度。',
'厂家精度只保存为型号规格；1000 µL系统误差±0.50%、CV 0.15%及5 µL系统误差±5.00%均不是本模型已验证精度。',
'三轴行程及目标匹配公差是场景工程约定，不是厂家行程、精度或安全距离；速度和碰撞检测未实现。',
'容器与吸头的容量、初始体积、工作位及目标关节位置由可信宿主登记，属于运行初始化输入，不能倒写为厂家部件规格。',
'4个暂存位的物件由宿主放置；本配置无夹爪，不提供跨槽搬运。直接吸排仅允许工作位。',
'attach/release要求宿主针对指定吸头、槽位和当前关节位置的确认；适配器只记录事件和附着身份，物理约束属于宿主。',
'注册场景回调后motion.move同步三轴；未注册时只改变位置状态。回调抛异常时内部状态不提交，外部场景效果可能未知。',
'read及state.read不推进时间；可信宿主显式提供共同simulation时钟，不实现每台仪器自动step。',
'去重仅本进程内按调用身份、实例、request_id缓存；不声称跨重启恰好一次。API可见性过滤不是Python对象或共享文件系统隔离。',
]
def export_opentrons_flex_contract_metadata():
"""Return type-only metadata; caller assembles source and artifact bindings."""
slots = _flex_copy.deepcopy(_FLEX_SLOTS)
for sid, slot in slots.items():
slot['read_binding'] = "OpentronsFlexSession.read(instance_id=..., state_ids=['%s'])" % sid
effects = {
'power.set': ['power.enabled'], 'motion.move': ['motion.x_m', 'motion.y_m', 'motion.z_m'],
'sample.aspirate': ['truth.containers', 'truth.tips', 'truth.tip_volume_m3', 'truth.transfers', 'sample.transfer_count'],
'sample.dispense': ['truth.containers', 'truth.tips', 'truth.tip_volume_m3', 'truth.transfers', 'sample.transfer_count'],
'tip.attach': ['tip.attached_id', 'tip.last_slot_id', 'tip.events', 'truth.tip_volume_m3', 'truth.tips'],
'tip.release': ['tip.attached_id', 'tip.last_slot_id', 'tip.events', 'truth.tip_volume_m3', 'truth.tips'],
'state.read': [], 'velocity.set': [], 'sample.mix': [], 'liquid_level.detect': []}
observes = {'power.set': ['power.enabled'], 'motion.move': ['motion.x_m', 'motion.y_m', 'motion.z_m'],
'tip.attach': ['tip.attached_id', 'tip.last_slot_id'], 'tip.release': ['tip.attached_id', 'tip.last_slot_id'],
'sample.aspirate': ['sample.transfer_count'], 'sample.dispense': ['sample.transfer_count'],
'state.read': list(_FLEX_PUBLIC), 'velocity.set': [], 'sample.mix': [], 'liquid_level.detect': []}
examples = {'power.set': {'enabled': True}, 'motion.move': {'x_m': -0.23, 'y_m': 0.21, 'z_m': 0.0},
'sample.aspirate': {'container_id': 'host_registered_donor', 'volume_m3': 5e-9},
'sample.dispense': {'container_id': 'host_registered_receiver', 'volume_m3': 5e-9},
'tip.attach': {'tip_id': 'host_registered_tip'}, 'tip.release': {'target_slot_id': 'A1'},
'state.read': {}, 'velocity.set': {}, 'sample.mix': {}, 'liquid_level.detect': {}}
summaries = {'power.set': '设置仿真供电，不清除样品或改变真实硬件。', 'motion.move': '原子提交三轴关节位置；已注册时调用宿主场景回调。',
'sample.aspirate': '从当前工作位目标容器向已附着吸头转移指定SI体积。', 'sample.dispense': '从已附着吸头向当前工作位目标容器转移指定SI体积。',
'tip.attach': '消费宿主确认并记录attach附着事件；不执行接触拾头。', 'tip.release': '消费宿主确认并记录release事件；吸头及剩余样品保留在宿主登记的释放位置。',
'state.read': '读取代理可见状态，不推进时间。', 'velocity.set': '速度及加速度曲线未实现。', 'sample.mix': '混合及组分输运未实现。', 'liquid_level.detect': '液面与传感器模型未实现。'}
preconditions = {'power.set': [], 'motion.move': ['已上电；三个有限关节坐标均在仿真约定范围内；仅目标匹配，无轨迹或碰撞互锁'],
'sample.aspirate': ['已上电并附着宿主登记吸头；容器为工作位且当前关节位置匹配登记目标；供体体积充足且吸头剩余容量充足'],
'sample.dispense': ['已上电并附着宿主登记吸头；容器为工作位且当前关节位置匹配登记目标；吸头体积充足且受体剩余容量充足'],
'tip.attach': ['已上电、没有已附着吸头；登记吸头位于工作位且当前位置匹配；宿主确认指定attach事件和同一位置'],
'tip.release': ['已上电、有已附着吸头；宿主确认同一吸头、释放槽位和当前位置'],
'state.read': [], 'velocity.set': [], 'sample.mix': [], 'liquid_level.detect': []}
caps = {}
for cid, input_schema in _FLEX_ARGUMENTS.items():
mode = 'host_required' if cid.startswith('tip.') else 'coupled' if cid == 'motion.move' else 'none'
model_note = '宿主约束已确认后记录attach/release事件；机器人与接触抓取absent。' if mode == 'host_required' else '三轴由运行状态单向同步到已注册宿主场景回调；未注册时只有状态更新。' if mode == 'coupled' else '纯体积账本或状态查询；没有液体、显示屏或其他可见几何变化。'
caps[cid] = {'availability': 'unsupported' if cid in _FLEX_UNSUPPORTED else 'implemented', 'visibility': 'agent',
'kind': 'query' if cid == 'state.read' else 'device_command', 'description_zh': summaries[cid],
'input_schema': _flex_copy.deepcopy(input_schema), 'output_schema': _flex_obj({sid: _flex_copy.deepcopy(slots[sid]['value_schema']) for sid in observes[cid]}),
'state_effects': [{'state_id': sid, 'timing': 'immediate', 'description_zh': '原子提交此状态；拒绝前提不改变状态'} for sid in effects[cid]],
'observes': observes[cid], 'preconditions_zh': preconditions[cid], 'example_arguments': [examples[cid]],
'binding': None if cid in _FLEX_UNSUPPORTED else "basic40_runtime_automation.OpentronsFlexSession.invoke(instance_id=..., capability_id='%s', arguments=..., request_id=...)" % cid,
'model_effects': {'mode': mode, 'binding_ids': [], 'description_zh': model_note},
'implementation': {'process': 'absent' if cid in _FLEX_UNSUPPORTED else 'implemented', 'scene': 'declared' if mode != 'none' else 'not_applicable', 'robot': 'absent', 'hardware': 'absent', 'host': 'implemented' if cid not in _FLEX_UNSUPPORTED else 'absent'}}
return {'asset_type_id': OPENTRONS_FLEX_TYPE, 'catalog_id': 'CHEM-175', 'asset_version': '1.0.1',
'state_slots': slots, 'capabilities': caps, 'parameters': {
'pipette_min_volume_m3': {'value': OPENTRONS_FLEX_MIN_M3, 'unit': 'm^3', 'evidence': 'catalog'},
'pipette_max_volume_m3': {'value': OPENTRONS_FLEX_MAX_M3, 'unit': 'm^3', 'evidence': 'catalog'},
'whole_instrument_width_m': {'value': 0.87, 'unit': 'm', 'evidence': 'catalog'},
'whole_instrument_depth_m': {'value': 0.69, 'unit': 'm', 'evidence': 'catalog'},
'whole_instrument_height_m': {'value': 0.84, 'unit': 'm', 'evidence': 'catalog'},
'whole_instrument_mass_kg': {'value': 88.5, 'unit': 'kg', 'evidence': 'catalog'},
'systematic_error_fraction_at_1000ul': {'value': 0.005, 'unit': '1', 'evidence': 'catalog', 'note_zh': '±厂家规格，不生成或验证误差'},
'cv_fraction_at_1000ul': {'value': 0.0015, 'unit': '1', 'evidence': 'catalog', 'note_zh': '厂家规格，不生成或验证误差'},
'systematic_error_fraction_at_5ul': {'value': 0.05, 'unit': '1', 'evidence': 'catalog', 'note_zh': '±厂家规格，不生成或验证误差'},
'tip_capacity_m3': {'value': None, 'unit': 'm^3', 'evidence': 'unknown', 'note_zh': '所用吸头型号不详；由宿主逐吸头登记运行容量'},
'pipette_component_mass_kg': {'value': None, 'unit': 'kg', 'evidence': 'unknown'},
'gantry_component_mass_kg': {'value': None, 'unit': 'kg', 'evidence': 'unknown'},
'motion_speed_m_s': {'value': None, 'unit': 'm/s', 'evidence': 'unknown'},
'volume_flow_rate_m3_s': {'value': None, 'unit': 'm^3/s', 'evidence': 'unknown'},
**{'motion_' + key + '_bounds': {'value': list(v), 'unit': 'm', 'evidence': 'assumed', 'note_zh': _FLEX_POSITION_NOTE} for key, v in _FLEX_LIMITS.items()}},
'host_api': {'create_instance': 'OpentronsFlexRuntime.create_instance(instance_id)',
'register_principal': 'OpentronsFlexRuntime.register_principal(principal_id,visibility=...,instance_ids=...)',
'host.register_container': 'OpentronsFlexRuntime.host_register_container(instance_id,container_id,slot_id=...,capacity_m3=...,volume_m3=...,position_m={x_m,y_m,z_m},evidence=...)',
'host.register_tip': 'OpentronsFlexRuntime.host_register_tip(instance_id,tip_id,slot_id=...,capacity_m3=...,position_m={x_m,y_m,z_m},evidence=...)',
'host.confirm_tip_event': 'OpentronsFlexRuntime.host_confirm_tip_event(instance_id,event=attach|release,tip_id=...,slot_id=...,position_m={x_m,y_m,z_m},evidence=...)',
'host.register_scene_adapter': 'OpentronsFlexRuntime.host_register_scene_adapter(instance_id,callback); callback(instance_id,{x_m,y_m,z_m})',
'host.sync_scene': 'OpentronsFlexRuntime.host_sync_scene(instance_id)',
'host.set_clock': 'OpentronsFlexRuntime.host_set_clock(time_s), monotonic common simulation clock'},
'limitations': list(_FLEX_LIMITATIONS), 'output_schema_scope': 'output_schema validates response.result; observations and describe are filtered by trusted host identity'}
class OpentronsFlexRuntime:
"""Trusted host for isolated instrument inventories, joint states and sessions."""
def __init__(self):
self.time_s = 0.0
self._instances, self._principals, self._requests = {}, {}, {}
self._lock = _flex_threading.RLock()
def create_instance(self, instance_id, asset_type_id=OPENTRONS_FLEX_TYPE):
with self._lock:
if not _flex_id(instance_id) or instance_id in self._instances or asset_type_id != OPENTRONS_FLEX_TYPE:
raise ValueError('Unique instance ID and supported asset type required')
state = {'power.enabled': False, 'motion.x_m': 0.0, 'motion.y_m': 0.0, 'motion.z_m': 0.0,
'motion.scene_adapter_registered': False, 'tip.attached_id': None, 'tip.last_slot_id': None, 'tip.events': [],
'deck.work_slot_ids': list(OPENTRONS_FLEX_WORK_SLOTS), 'deck.staging_slot_ids': list(OPENTRONS_FLEX_STAGING_SLOTS),
'sample.transfer_count': 0, 'truth.tip_volume_m3': None, 'truth.containers': [], 'truth.tips': [], 'truth.transfers': []}
self._instances[instance_id] = {'state': state, 'revision': 0, 'containers': {}, 'tips': {}, 'evidence': {}, 'tip_confirmation': None, 'adapter': None}
def register_principal(self, principal_id, *, visibility, instance_ids=None):
with self._lock:
if not _flex_id(principal_id) or principal_id in self._principals or visibility not in ('agent', 'debug', 'evaluator'):
raise ValueError('Unique host-authenticated principal and valid visibility required')
if instance_ids is not None and (not isinstance(instance_ids, (list, tuple, set, frozenset)) or any(not isinstance(i, str) or i not in self._instances for i in instance_ids)):
raise ValueError('Invalid instance scope')
self._principals[principal_id] = (visibility, None if instance_ids is None else frozenset(instance_ids))
def session(self, principal_id):
return OpentronsFlexSession(self, principal_id)
def _host_instance(self, instance_id):
if not isinstance(instance_id, str) or instance_id not in self._instances:
raise ValueError('Unknown instance')
return self._instances[instance_id]
def _instance(self, instance_id, principal):
if not isinstance(instance_id, str) or principal not in self._principals:
return None
scope = self._principals[principal][1]
return self._instances.get(instance_id) if scope is None or instance_id in scope else None
@staticmethod
def _position_valid(position):
return isinstance(position, dict) and set(position) == set(_FLEX_LIMITS) and all(_flex_number(position[k]) and limits[0] <= position[k] <= limits[1] for k, limits in _FLEX_LIMITS.items())
@staticmethod
def _position(item):
return {key: item['state']['motion.' + key] for key in _FLEX_LIMITS}
@staticmethod
def _position_matches(left, right):
return all(abs(left[key] - right[key]) <= 1e-9 for key in _FLEX_LIMITS)
@staticmethod
def _sync_inventory(item):
state = item['state']
state['truth.containers'] = _flex_copy.deepcopy(list(item['containers'].values()))
state['truth.tips'] = _flex_copy.deepcopy(list(item['tips'].values()))
tip_id = state['tip.attached_id']
state['truth.tip_volume_m3'] = item['tips'][tip_id]['volume_m3'] if tip_id is not None else None
def host_register_container(self, instance_id, container_id, *, slot_id, capacity_m3, volume_m3, position_m, evidence):
with self._lock:
item = self._host_instance(instance_id)
if (not _flex_id(container_id) or container_id in item['containers'] or container_id in item['tips'] or not isinstance(slot_id, str) or slot_id not in OPENTRONS_FLEX_ALL_SLOTS
or not _flex_number(capacity_m3) or capacity_m3 <= 0 or not _flex_number(volume_m3) or not 0 <= volume_m3 <= capacity_m3
or not self._position_valid(position_m) or not _flex_id(evidence)):
raise ValueError('Valid unique container, slot, finite capacity/inventory, target position and evidence required')
item['containers'][container_id] = {'container_id': container_id, 'slot_id': slot_id, 'capacity_m3': float(capacity_m3), 'volume_m3': float(volume_m3), 'position_m': _flex_copy.deepcopy(position_m)}
item['evidence'][container_id] = evidence
self._sync_inventory(item)
item['revision'] += 1
def host_register_tip(self, instance_id, tip_id, *, slot_id, capacity_m3, position_m, evidence):
with self._lock:
item = self._host_instance(instance_id)
if (not _flex_id(tip_id) or tip_id in item['tips'] or tip_id in item['containers'] or not isinstance(slot_id, str) or slot_id not in OPENTRONS_FLEX_ALL_SLOTS
or not _flex_number(capacity_m3) or not OPENTRONS_FLEX_MIN_M3 <= capacity_m3 <= OPENTRONS_FLEX_MAX_M3
or not self._position_valid(position_m) or not _flex_id(evidence)):
raise ValueError('Valid unique empty tip, slot, capacity, target position and evidence required')
item['tips'][tip_id] = {'tip_id': tip_id, 'slot_id': slot_id, 'capacity_m3': float(capacity_m3), 'volume_m3': 0.0, 'position_m': _flex_copy.deepcopy(position_m)}
item['evidence'][tip_id] = evidence
self._sync_inventory(item)
item['revision'] += 1
def host_confirm_tip_event(self, instance_id, *, event, tip_id, slot_id, position_m, evidence):
"""Trusted assertion of an external host attachment/release constraint.
Confirmation is bound to current position and consumed once by tip API;
host must supply the actual constraint or external confirmation. No robot
contact, collision, latch force or constraint creation occurs here.
"""
with self._lock:
item = self._host_instance(instance_id)
if (event not in ('attach', 'release') or not isinstance(tip_id, str) or tip_id not in item['tips']
or not isinstance(slot_id, str) or slot_id not in OPENTRONS_FLEX_ALL_SLOTS or not self._position_valid(position_m)
or not self._position_matches(position_m, self._position(item)) or not _flex_id(evidence)):
raise ValueError('Known tip, slot, current position and host constraint evidence required')
item['tip_confirmation'] = {'event': event, 'tip_id': tip_id, 'slot_id': slot_id, 'position_m': _flex_copy.deepcopy(position_m), 'evidence': evidence}
def host_register_scene_adapter(self, instance_id, callback):
with self._lock:
item = self._host_instance(instance_id)
if not callable(callback):
raise ValueError('Trusted callable scene adapter required')
item['adapter'] = callback
item['state']['motion.scene_adapter_registered'] = True
item['revision'] += 1
def host_sync_scene(self, instance_id):
with self._lock:
item = self._host_instance(instance_id)
if item['adapter'] is None:
raise ValueError('No scene adapter registered')
item['adapter'](instance_id, self._position(item))
def host_set_clock(self, time_s):
with self._lock:
if not _flex_number(time_s) or time_s < self.time_s:
raise ValueError('Finite nondecreasing shared host time required')
self.time_s = float(time_s)
def debug_snapshot(self):
with self._lock:
return {'time_s': self.time_s, 'instances': {iid: _flex_copy.deepcopy({k: v for k, v in item.items() if k != 'adapter'}) for iid, item in self._instances.items()}}
def _response(self, instance_id, request_id=None, *, status='succeeded', result=None, code=None, side_effects='none'):
item = self._instances.get(instance_id) if isinstance(instance_id, str) else None
return {'protocol_version': '1.0.0', 'instance_id': instance_id if isinstance(instance_id, str) else None,
'request_id': request_id if isinstance(request_id, str) else None, 'operation_id': None,
'status': status, 'state_revision': item['revision'] if item else None,
'clock': {'domain': 'simulation', 'time_s': self.time_s}, 'result': _flex_copy.deepcopy(result) if result is not None else {}, 'observations': {},
'error': {'code': code, 'message': {'PRECONDITION_FAILED': 'Required host registration, position, attachment or volume constraint is not satisfied.', 'DEVICE_ERROR': 'Scene adapter did not complete; external scene effects require host inspection.'}.get(code, code), 'retryable': False, 'side_effects': side_effects} if code else None}
@staticmethod
def _arguments_valid(cid, args):
if not isinstance(args, dict) or set(args) != set(_FLEX_ARGUMENTS[cid]['properties']):
return False
if cid == 'power.set':
return type(args['enabled']) is bool
if cid == 'motion.move':
return OpentronsFlexRuntime._position_valid(args)
if cid in ('sample.aspirate', 'sample.dispense'):
return _flex_id(args['container_id']) and _flex_number(args['volume_m3']) and OPENTRONS_FLEX_MIN_M3 <= args['volume_m3'] <= OPENTRONS_FLEX_MAX_M3
if cid == 'tip.attach':
return _flex_id(args['tip_id'])
if cid == 'tip.release':
return isinstance(args['target_slot_id'], str) and args['target_slot_id'] in OPENTRONS_FLEX_ALL_SLOTS
return True
def _apply(self, item, iid, cid, args, rid):
state = item['state']
fail = lambda: self._response(iid, rid, status='rejected', code='PRECONDITION_FAILED')
if cid == 'state.read':
return self._response(iid, rid, result={sid: state[sid] for sid in _FLEX_PUBLIC})
if cid != 'power.set' and not state['power.enabled']:
return fail()
if cid == 'power.set':
state['power.enabled'] = args['enabled']
elif cid == 'motion.move':
if item['adapter'] is not None:
try:
item['adapter'](iid, _flex_copy.deepcopy(args))
except Exception:
return self._response(iid, rid, status='failed', code='DEVICE_ERROR', side_effects='unknown')
for key, value in args.items():
state['motion.' + key] = float(value)
# A confirmation cannot authorize a later visit to the same location.
item['tip_confirmation'] = None
elif cid.startswith('sample.'):
container = item['containers'].get(args['container_id'])
tip_id = state['tip.attached_id']
if container is None or tip_id is None or container['slot_id'] not in OPENTRONS_FLEX_WORK_SLOTS or not self._position_matches(self._position(item), container['position_m']):
return fail()
tip = item['tips'][tip_id]
donor, receiver = (container, tip) if cid == 'sample.aspirate' else (tip, container)
volume = float(args['volume_m3'])
if donor['volume_m3'] < volume or receiver['capacity_m3'] - receiver['volume_m3'] < volume:
return fail()
donor['volume_m3'] -= volume
receiver['volume_m3'] += volume
sequence = state['sample.transfer_count'] + 1
state['truth.transfers'].append({'transaction_id': '%s.transfer.%d' % (iid, sequence), 'donor_id': donor.get('container_id', donor.get('tip_id')), 'receiver_id': receiver.get('container_id', receiver.get('tip_id')), 'volume_m3': volume, 'unit': 'm^3', 'kind': cid.split('.')[1], 'time_s': self.time_s})
state['sample.transfer_count'] = sequence
self._sync_inventory(item)
elif cid in ('tip.attach', 'tip.release'):
event = cid.split('.')[1]
tip_id = args.get('tip_id') if event == 'attach' else state['tip.attached_id']
tip = item['tips'].get(tip_id)
slot = tip['slot_id'] if tip is not None and event == 'attach' else args.get('target_slot_id')
confirmation = item['tip_confirmation']
if (tip is None or (event == 'attach' and (state['tip.attached_id'] is not None or slot not in OPENTRONS_FLEX_WORK_SLOTS or not self._position_matches(self._position(item), tip['position_m'])))
or confirmation is None or any(confirmation[k] != v for k, v in (('event', event), ('tip_id', tip_id), ('slot_id', slot)))
or not self._position_matches(self._position(item), confirmation['position_m'])):
return fail()
state['tip.attached_id'] = tip_id if event == 'attach' else None
state['tip.last_slot_id'] = slot
tip['slot_id'] = None if event == 'attach' else slot
if event == 'release':
tip['position_m'] = self._position(item)
state['tip.events'].append({'event': event, 'tip_id': tip_id, 'slot_id': slot, 'time_s': self.time_s, 'constraint_authority': 'host'})
item['tip_confirmation'] = None
self._sync_inventory(item)
item['revision'] += 1
observes = export_opentrons_flex_contract_metadata()['capabilities'][cid]['observes']
return self._response(iid, rid, result={sid: state[sid] for sid in observes})
def _invoke(self, principal, iid, cid, args, rid):
with self._lock:
item = self._instance(iid, principal)
if item is None:
# Do not expose revision of an existing out-of-scope instance.
response = self._response(None, rid, status='rejected', code='UNKNOWN_INSTANCE')
response['instance_id'] = iid if isinstance(iid, str) else None
return response
if not _flex_id(rid) or not isinstance(cid, str):
return self._response(iid, rid, status='rejected', code='INVALID_ARGUMENT')
try:
fingerprint = _flex_json.dumps([cid, args], sort_keys=True, allow_nan=False, separators=(',', ':'))
except (ValueError, TypeError, OverflowError):
return self._response(iid, rid, status='rejected', code='INVALID_ARGUMENT')
key = (principal, iid, rid)
if key in self._requests:
previous, response = self._requests[key]
return _flex_copy.deepcopy(response) if previous == fingerprint else self._response(iid, rid, status='rejected', code='REQUEST_CONFLICT')
if cid not in _FLEX_ARGUMENTS:
response = self._response(iid, rid, status='rejected', code='UNKNOWN_CAPABILITY')
elif not self._arguments_valid(cid, args):
response = self._response(iid, rid, status='rejected', code='INVALID_ARGUMENT')
elif cid in _FLEX_UNSUPPORTED:
response = self._response(iid, rid, status='unsupported', code='UNSUPPORTED')
else:
response = self._apply(item, iid, cid, args, rid)
self._requests[key] = (fingerprint, _flex_copy.deepcopy(response))
return response
class OpentronsFlexSession:
"""Identity-bound public protocol facade; host assigns visibility and scope."""
def __init__(self, host, principal_id):
if not isinstance(principal_id, str) or principal_id not in host._principals:
raise ValueError('Host authentication and registration required')
self.__host, self.__principal = host, principal_id
def _visible(self):
return set(_FLEX_PUBLIC) if self.__host._principals[self.__principal][0] == 'agent' else set(_FLEX_SLOTS)
def describe(self, *, asset_type_id=None, instance_id=None):
with self.__host._lock:
h = self.__host
if (asset_type_id is None) == (instance_id is None):
return h._response(None, status='rejected', code='INVALID_ARGUMENT')
if (asset_type_id is not None and asset_type_id != OPENTRONS_FLEX_TYPE) or (instance_id is not None and h._instance(instance_id, self.__principal) is None):
return h._response(None, status='rejected', code='UNKNOWN_INSTANCE')
result = export_opentrons_flex_contract_metadata()
result.pop('host_api')
allowed = self._visible()
result['state_slots'] = {sid: slot for sid, slot in result['state_slots'].items() if sid in allowed}
for cap in result['capabilities'].values():
cap['state_effects'] = [entry for entry in cap['state_effects'] if entry['state_id'] in allowed]
if cap['model_effects']['mode'] == 'coupled' and instance_id is not None and h._instances[instance_id]['adapter'] is None:
cap['model_effects'] = {'mode': 'none', 'binding_ids': [], 'description_zh': '当前实例未注册宿主场景回调；仅位置状态变更。'}
cap['implementation']['scene'] = 'absent'
result['instance_id'] = instance_id
return result
def read(self, *, instance_id, state_ids=None):
with self.__host._lock:
h, allowed = self.__host, self._visible()
item = h._instance(instance_id, self.__principal)
if item is None:
return h._response(None, status='rejected', code='UNKNOWN_INSTANCE')
if state_ids is None:
state_ids = sorted(allowed)
if not isinstance(state_ids, list) or any(not isinstance(sid, str) for sid in state_ids) or len(set(state_ids)) != len(state_ids):
return h._response(instance_id, status='rejected', code='INVALID_ARGUMENT')
if any(sid not in allowed for sid in state_ids):
return h._response(instance_id, status='rejected', code='ACCESS_DENIED')
response = h._response(instance_id)
for sid in state_ids:
value = _flex_copy.deepcopy(item['state'][sid])
response['observations'][sid] = {'value': value, 'unit': _FLEX_SLOTS[sid]['unit'], 'quality': 'unavailable' if value is None else 'estimated' if _FLEX_SLOTS[sid]['origin'] == 'process_truth' else 'valid', 'sample_time_s': h.time_s, 'sample_window_s': None}
if value is None:
response['observations'][sid]['reason'] = 'No current attached tip or prior slot event.'
return response
def invoke(self, *, instance_id, capability_id, arguments, request_id):
return self.__host._invoke(self.__principal, instance_id, capability_id, arguments, request_id)
def write(self, *, instance_id, state_id, value, request_id):
with self.__host._lock:
if self.__host._instance(instance_id, self.__principal) is None:
return self.__host._response(None, request_id, status='rejected', code='UNKNOWN_INSTANCE')
slot = _FLEX_SLOTS.get(state_id) if isinstance(state_id, str) else None
if slot is None or slot['write_via'] is None or state_id not in self._visible():
return self.__host._response(instance_id, request_id, status='rejected', code='ACCESS_DENIED')
via = slot['write_via']
return self.invoke(instance_id=instance_id, capability_id=via['capability_id'], arguments={via['parameter']: value}, request_id=request_id)
# END CHEM-175 OPENTRONS FLEX APPEND-ONLY RUNTIME
# BEGIN CHEM-174 QUANTOS Q2 XPE206DR APPEND-ONLY RUNTIME
import copy as _qt_copy
import json as _qt_json
import math as _qt_math
import threading as _qt_threading
QUANTOS_Q2_TYPE = 'instrument.mt_quantos_q2_xpe206dr'
def _qt_number(v):
try:
return type(v) in (int, float) and _qt_math.isfinite(v)
except (OverflowError, TypeError):
return False
def _qt_text(v):
return isinstance(v, str) and bool(v.strip())
def _qt_num(unit, minimum=0, maximum=None, nullable=False):
s = {'type': 'number', 'x-unit': unit}
if minimum is not None:
s['minimum'] = minimum
if maximum is not None:
s['maximum'] = maximum
return {'anyOf': [s, {'type': 'null'}]} if nullable else s
def _qt_obj(props):
return {'type': 'object', 'properties': props, 'required': list(props), 'additionalProperties': False}
def _qt_slot(schema, unit, origin, via=None, parameter=None, visibility='agent'):
return {'value_schema': schema, 'unit': unit, 'origin': origin, 'visibility': visibility,
'access': 'read_write' if via else 'read_only', 'reference_conditions': None,
'write_via': {'capability_id': via, 'parameter': parameter, 'fixed_arguments': {}} if via else None,
'sampling': {'mode': 'instant', 'time_domain': 'simulation', 'window': None}}
_QT_BOOL = {'type': 'boolean'}
_QT_STR = {'type': 'string', 'minLength': 1}
_QT_NS = {'anyOf': [_QT_STR, {'type': 'null'}]}
_QT_SLOTS = {
'power.enabled': _qt_slot(_QT_BOOL, '1', 'setpoint', 'power.set', 'enabled'),
'dosing.target_mass_kg': _qt_slot(_qt_num('kg', 1e-6, .005, True), 'kg', 'setpoint', 'dosing.set_target', 'target_mass_kg'),
'dosing.tolerance_kg': _qt_slot(_qt_num('kg', nullable=True), 'kg', 'setpoint', 'dosing.set_tolerance', 'tolerance_kg'),
'head.selected_id': _qt_slot(_QT_NS, '1', 'setpoint', 'head.select', 'head_id'),
'head.loaded_id': _qt_slot(_QT_NS, '1', 'scene'),
'container.position_id': _qt_slot(_QT_NS, '1', 'setpoint', 'container.select_position', 'position_id'),
'container.loaded_id': _qt_slot(_QT_NS, '1', 'scene'),
'container.attachment_constraint_id': _qt_slot(_QT_NS, '1', 'scene'),
'scene.door_opening_m': _qt_slot(_qt_num('m', nullable=True), 'm', 'scene', 'door.set_opening', 'opening_m'),
'balance.tared': _qt_slot(_QT_BOOL, '1', 'derived'),
'measurement.balance_net_kg': _qt_slot(_qt_num('kg', nullable=True), 'kg', 'derived'),
'measurement.actual_dosed_kg': _qt_slot(_qt_num('kg', nullable=True), 'kg', 'derived'),
'measurement.error_kg': _qt_slot(_qt_num('kg', minimum=None, nullable=True), 'kg', 'derived'),
'measurement.out_of_tolerance': _qt_slot({'anyOf': [_QT_BOOL, {'type': 'null'}]}, '1', 'derived'),
'dosing.elapsed_s': _qt_slot(_qt_num('s'), 's', 'derived'),
'dosing.status': _qt_slot({'type': 'string', 'enum': ['idle', 'running', 'succeeded', 'failed', 'cancelled']}, '1', 'derived'),
'simulation.rate_configured': _qt_slot(_QT_BOOL, '1', 'derived'),
'truth.source_mass_kg': _qt_slot(_qt_num('kg', nullable=True), 'kg', 'process_truth', visibility='debug'),
'truth.container_mass_kg': _qt_slot(_qt_num('kg', nullable=True), 'kg', 'process_truth', visibility='debug'),
'truth.actual_dosed_kg': _qt_slot(_qt_num('kg', nullable=True), 'kg', 'process_truth', visibility='debug'),
}
_QT_READ_IDS = ['dosing.status', 'dosing.target_mass_kg', 'dosing.tolerance_kg', 'measurement.actual_dosed_kg', 'measurement.error_kg', 'measurement.out_of_tolerance', 'dosing.elapsed_s', 'measurement.balance_net_kg']
_QT_MEASURE_IDS = [k for k in _QT_SLOTS if k.startswith('measurement.')]
_QT_LIMITATIONS = [
'仅实现单个装粉头槽与一个已放置容器；可选30位自动进样器未装配，容器位置选择只匹配宿主登记位置，不驱动转盘。',
'范围1 mg–5 g仅适用于宿主明确确认的自由流动粉末；无默认物料、库存、允许偏差、速率、天平容量或读数精度。',
'碳酸钙10 mg典型22 s、RSD 1.15%；50 mg RSD 0.26%；1000 mg典型71 s仅作为清单资料，不计算任意粉末速率、RSD或随机误差。',
'投料采用显式宿主速率与理想闭环连续停止模型，实际读数为estimated理想质量代理；没有粉体流变、扬尘、残留、天平动态或真实误差模型。',
'门为宿主确认的展示滑移关节，几何行程由宿主带证据配置；不声称是原厂门行程、速度或安全互锁认证。',
'attach/release仅在外部约束回调明确确认后登记；没有机器人规划、接触抓取或硬件驱动。',
'只有可信宿主管理库存、物质转移账本、身份和时间；API过滤不是Python或共享文件系统隔离。请求去重仅当前内存有效。',
]
def export_quantos_q2_contract_metadata():
slots = _qt_copy.deepcopy(_QT_SLOTS)
for sid, slot in slots.items():
slot['read_binding'] = 'QuantosQ2Session.read(instance_id=..., state_ids=[%r])' % sid
slots['scene.door_opening_m']['reference_conditions'] = 'quantos__door_slide.location.y=q; +Y opening from authored closed pose; host-configured geometric upper bound'
specs = {
'power.set': ({'enabled': _QT_BOOL}, ['power.enabled'] + _QT_MEASURE_IDS + ['balance.tared', 'dosing.status'], ['power.enabled'], {'enabled': True}, ['terminal'], []),
'dosing.set_target': ({'target_mass_kg': _qt_num('kg', 1e-6, .005)}, ['dosing.target_mass_kg'] + _QT_MEASURE_IDS, ['dosing.target_mass_kg'], {'target_mass_kg': 1e-5}, ['terminal'], ['上电且无运行操作；范围仅自由流动粉末。']),
'dosing.set_tolerance': ({'tolerance_kg': _qt_num('kg')}, ['dosing.tolerance_kg'] + _QT_MEASURE_IDS, ['dosing.tolerance_kg'], {'tolerance_kg': 1e-6}, ['terminal'], ['上电且无运行操作；允许偏差由使用者显式设置。']),
'head.select': ({'head_id': _QT_STR}, ['head.selected_id'], ['head.selected_id'], {'head_id': 'host_head'}, ['dosing_head', 'head_slot'], ['上电、空闲；head_id匹配宿主已装载的唯一头。']),
'container.select_position': ({'position_id': _QT_STR}, ['container.position_id', 'balance.tared'] + _QT_MEASURE_IDS, ['container.position_id'], {'position_id': 'balance_pan'}, ['sample_container', 'balance_pan'], ['上电、空闲；position_id匹配宿主已放置容器的位置，无自动移动。']),
'door.set_opening': ({'opening_m': _qt_num('m')}, ['scene.door_opening_m', 'balance.tared'] + _QT_MEASURE_IDS, ['scene.door_opening_m'], {'opening_m': 0}, ['draft_door'], ['空闲；有宿主配置的几何行程与场景回调；0<=q<=行程；回调返回True才提交。']),
'balance.tare': ({}, ['balance.tared'] + _QT_MEASURE_IDS, ['balance.tared', 'measurement.balance_net_kg'], {}, ['balance'], ['上电、空闲、门关；容器位置已选；显式理想观察模型已配置。']),
'dosing.start': ({}, ['dosing.status', 'dosing.elapsed_s', 'truth.actual_dosed_kg'] + _QT_MEASURE_IDS, _QT_READ_IDS, {}, ['dosing_head', 'balance', 'sample_container'], ['上电、门关、已去皮、目标与偏差已设置；已选宿主兼容自由流动粉末头和容器位置；显式速率与正库存。']),
'dosing.read': ({}, [], _QT_READ_IDS, {}, ['terminal', 'balance'], []),
'dosing.poll': ({'operation_id': _QT_STR}, [], _QT_READ_IDS, {'operation_id': 'qt_op_1'}, ['terminal'], ['操作属于当前身份与实例。']),
'dosing.cancel': ({'operation_id': _QT_STR}, ['dosing.status'], _QT_READ_IDS, {'operation_id': 'qt_op_1'}, ['terminal', 'dosing_head'], ['操作属于当前身份与实例；取消保留已转移粉末与耗时。']),
'autosampler.advance': ({}, [], [], {}, ['autosampler_option'], ['该批次单头配置未安装可选30位自动进样器。']),
}
desc = {'power.set': '设置仿真供电，断电取消任务并保留已投料。', 'dosing.set_target': '设置目标质量。', 'dosing.set_tolerance': '设置绝对允许偏差。', 'head.select': '选择宿主装入的粉末头。', 'container.select_position': '选择宿主已经放置容器的位置。', 'door.set_opening': '设置门展示滑移位置并等待宿主场景确认。', 'balance.tare': '记录显式理想读数模型的容器质量基线。', 'dosing.start': '启动有源库存守恒的异步仿真投料。', 'dosing.read': '读取投料结果且不推进时间。', 'dosing.poll': '读取当前身份拥有的投料进度。', 'dosing.cancel': '取消投料且保留部分转移。', 'autosampler.advance': '可选自动进样器未装配，不支持转位。'}
caps = {}
for cid, (props, effects, observed, example, components, prereq) in specs.items():
scene, unsupported = cid == 'door.set_opening', cid == 'autosampler.advance'
entries = [{'state_id': sid, 'timing': 'immediate', 'description_zh': '同步更新本次声明的状态。'} for sid in dict.fromkeys(effects)]
if cid == 'dosing.start':
entries += [{'state_id': sid, 'timing': 'on_step', 'description_zh': '宿主共同时间推进后更新守恒物料、理想观测和完成状态。'} for sid in ['truth.source_mass_kg', 'truth.container_mass_kg', 'truth.actual_dosed_kg', 'dosing.elapsed_s', 'dosing.status'] + _QT_MEASURE_IDS]
caps[cid] = {'name_zh': desc[cid], 'description_zh': desc[cid], 'kind': 'query' if cid in ('dosing.read', 'dosing.poll') else 'configuration' if cid in ('head.select', 'container.select_position') else 'device_command', 'visibility': 'agent', 'availability': 'unsupported' if unsupported else 'implemented',
'component_ids': components, 'input_schema': _qt_obj(_qt_copy.deepcopy(props)), 'output_schema': _qt_obj({sid: _qt_copy.deepcopy(slots[sid]['value_schema']) for sid in observed}), 'observes': observed,
'state_effects': entries, 'preconditions_zh': prereq, 'example_arguments': [_qt_copy.deepcopy(example)],
'binding': None if unsupported else 'basic40_runtime_automation.QuantosQ2Session.invoke(instance_id=..., capability_id=%r, arguments=..., request_id=...)' % cid,
'implementation': {'process': 'absent' if unsupported else 'implemented', 'scene': 'implemented' if scene else 'not_applicable', 'host': 'absent' if unsupported else 'implemented', 'hardware': 'absent', 'robot': 'absent'},
'model_effects': {'mode': 'host_required' if scene else 'none', 'binding_ids': [], 'description_zh': 'scene_adapter(instance_id,{scene.door_opening_m:q})返回True后提交，apply_quantos_q2_scene_patch映射quantos__door_slide.location.y=q。' if scene else '逻辑装载、称量和投料读数不驱动额外几何；粒子粉末流和屏幕同步未实现。'},
'execution_notes': {'mode': 'asynchronous' if cid == 'dosing.start' else 'synchronous', 'time_domain': 'simulation', 'cancellable': cid == 'dosing.start', 'completion_zh': '理想观测达到目标即停止，缺料则failed保留部分转移。' if cid == 'dosing.start' else '返回succeeded表示本次操作完成。', 'partial_failure_zh': '取消、断电和缺料保留已转移的质量和已用时间；外部场景回调失败的副作用为unknown。', 'retry_zh': '当前内存中相同请求ID及参数返回原响应；不同参数拒绝；不保证跨重启。'},
'errors': [{'code': c, 'description_zh': d, 'side_effects': s} for c, d, s in [('INVALID_ARGUMENT', '参数类型、范围或额外字段无效。', 'none'), ('UNKNOWN_INSTANCE', '实例不存在或不在身份范围。', 'none'), ('UNKNOWN_CAPABILITY', '能力不存在。', 'none'), ('ACCESS_DENIED', '槽不可写或身份不能访问。', 'none'), ('PRECONDITION_FAILED', '供电、装载、门、去皮、配置或库存条件不满足。', 'none'), ('BUSY', '投料占用设备。', 'none'), ('REQUEST_CONFLICT', '请求ID参数冲突。', 'none'), ('UNKNOWN_OPERATION', '操作不属于当前身份与实例。', 'none'), ('UNSUPPORTED', '能力未装配或门场景未绑定。', 'none'), ('DEVICE_ERROR', '场景回调失败或未确认。', 'unknown'), ('SOURCE_DEPLETED', '粉末源在达到目标前耗尽；保留部分投料。', 'partial')]]}
return {'asset_type_id': QUANTOS_Q2_TYPE, 'asset_version': '1.0.2', 'catalog_id': 'CHEM-174', 'state_slots': slots, 'capabilities': caps,
'parameters': {k: {'value': v, 'unit': u, 'evidence': e} for k,v,u,e in [('target_range_kg', [1e-6,.005], 'kg', 'catalog'), ('caco3_10mg_typical_time_s',22,'s','catalog'), ('caco3_10mg_rsd',.0115,'1','catalog'), ('caco3_50mg_rsd',.0026,'1','catalog'), ('caco3_1000mg_typical_time_s',71,'s','catalog'), ('optional_autosampler_positions',30,'1','catalog'), ('powder_rate_kg_s',None,'kg/s','unknown'), ('balance_readability_kg',None,'kg','unknown'), ('balance_capacity_kg',None,'kg','unknown'), ('door_manufacturer_travel_m',None,'m','unknown')]},
'host_api': {k: {'entrypoint': 'QuantosQ2Runtime.'+k, 'description_zh': d} for k,d in {
'create_instance':'独立实例，可选场景回调；所有未给出的物料和参数保持null。', 'register_principal':'可信宿主固定身份、权限与实例范围。', 'host_configure_geometry':'显式几何门行程和证据；关闭位置必须由回调确认。', 'host_load_head':'门开时装入唯一自由流动粉末头，源库存仅debug。', 'host_load_container':'门开时登记容器、位置和内容质量；不会移动几何。', 'host_configure_dosing':'显式正速率和理想质量观察证据；无厂家默认速率。', 'host_step':'dt_s与world_time_s必须匹配共同世界时钟，守恒转移并保存带供体/受体/量的账本。', 'host_attach':'外部attach事件与唯一约束ID确认，robot absent。', 'host_release':'外部release确认后清除约束，不移出容器。', 'host_unload_container':'门开且无附着无任务时移除容器引用，返回已保留内容质量给宿主。', 'host_unload_head':'门开且空闲时卸头，返回剩余粉末质量给宿主。', 'host_transfer_ledger':'仅可信宿主读取带事务ID的物质转移账本。'}.items()},
'limitations': list(_QT_LIMITATIONS), 'output_schema_scope': 'capabilities.output_schema validates response.result; no process truth/evidence in agent response'}
def apply_quantos_q2_scene_patch(scene, patch):
"""Blender scene bridge; caller must separately verify evaluated geometry."""
if not isinstance(patch, dict) or set(patch) != {'scene.door_opening_m'} or not _qt_number(patch['scene.door_opening_m']) or patch['scene.door_opening_m'] < 0:
raise ValueError('Only a finite nonnegative door patch is accepted')
door = scene.objects.get('quantos__door_slide')
if door is None:
raise ValueError('Quantos door target missing')
if door.animation_data and (door.animation_data.action or door.animation_data.drivers):
raise ValueError('Door must have a single host authority without animation/driver override')
if len(door.constraints):
raise ValueError('Door constraints require explicit authority reconciliation')
door.location.y = float(patch['scene.door_opening_m'])
return True
class QuantosQ2Runtime:
"""Trusted host. Hand an authenticated QuantosQ2Session to the caller."""
def __init__(self):
self.time_s, self._counter = 0.0, 0
self._instances, self._principals, self._requests, self._operations = {}, {}, {}, {}
self._ledger, self._events, self._lock = [], [], _qt_threading.RLock()
def create_instance(self, instance_id, scene_adapter=None):
with self._lock:
if not _qt_text(instance_id) or instance_id in self._instances or (scene_adapter is not None and not callable(scene_adapter)):
raise ValueError('Unique ID and optional callable scene adapter required')
s = {k: None for k in _QT_SLOTS}
s.update({'power.enabled': False, 'balance.tared': False, 'dosing.elapsed_s': 0.0, 'dosing.status': 'idle', 'simulation.rate_configured': False})
self._instances[instance_id] = {'state': s, 'revision': 0, 'adapter': scene_adapter, 'door_travel_m': None, 'rate_kg_s': None, 'position_id': None, 'tare_mass_kg': None, 'active_operation': None, 'evidence': {}}
def register_principal(self, principal_id, *, visibility, instance_ids=None):
with self._lock:
if not _qt_text(principal_id) or principal_id in self._principals or visibility not in ('agent', 'debug', 'evaluator'):
raise ValueError('Host-assigned unique identity and valid visibility required')
if instance_ids is not None and (not isinstance(instance_ids, (list, tuple, set, frozenset)) or any(not isinstance(i,str) or i not in self._instances for i in instance_ids)):
raise ValueError('Invalid instance scope')
self._principals[principal_id] = (visibility, None if instance_ids is None else frozenset(instance_ids))
def session(self, principal_id):
if not isinstance(principal_id,str) or principal_id not in self._principals:
raise ValueError('Host authentication required')
return QuantosQ2Session(self, principal_id)
def _get(self, iid, principal=None):
p = self._principals.get(principal) if principal else None
return self._instances.get(iid) if isinstance(iid,str) and (not principal or (p and (p[1] is None or iid in p[1]))) else None
def _idle(self, iid, door_open=False):
i = self._get(iid)
if i is None or i['active_operation'] is not None or (door_open and not (i['state']['scene.door_opening_m'] is not None and i['state']['scene.door_opening_m'] > 0)):
raise ValueError('Known idle instance and required open door needed')
return i
@staticmethod
def _refresh(i):
s = i['state']
available = s['power.enabled'] and s['balance.tared'] and s['simulation.rate_configured'] and s['container.loaded_id'] is not None
s['measurement.balance_net_kg'] = max(0.0, s['truth.container_mass_kg'] - i['tare_mass_kg']) if available else None
actual = s['truth.actual_dosed_kg'] if available else None
s['measurement.actual_dosed_kg'] = actual
s['measurement.error_kg'] = actual - s['dosing.target_mass_kg'] if actual is not None and s['dosing.target_mass_kg'] is not None else None
s['measurement.out_of_tolerance'] = abs(s['measurement.error_kg']) > s['dosing.tolerance_kg'] if s['measurement.error_kg'] is not None and s['dosing.tolerance_kg'] is not None else None
def host_configure_geometry(self, iid, *, door_travel_m, evidence):
with self._lock:
i = self._idle(iid)
if not _qt_number(door_travel_m) or door_travel_m <= 0 or not _qt_text(evidence) or i['adapter'] is None or i['state']['head.loaded_id'] or i['state']['container.loaded_id']:
raise ValueError('Empty idle geometry, scene adapter, positive explicit travel and evidence required')
if i['adapter'](iid, {'scene.door_opening_m': 0.0}) is not True:
raise RuntimeError('External scene did not confirm initialization; side effects unknown')
i['door_travel_m'], i['evidence']['geometry'] = float(door_travel_m), evidence
i['state']['scene.door_opening_m'] = 0.0
i['revision'] += 1
def host_load_head(self, iid, *, head_id, source_mass_kg, free_flowing, evidence):
with self._lock:
i = self._idle(iid, True)
if not _qt_text(head_id) or not _qt_text(evidence) or not _qt_number(source_mass_kg) or source_mass_kg < 0 or free_flowing is not True or i['state']['head.loaded_id'] is not None or any(x['state']['head.loaded_id'] == head_id for x in self._instances.values()):
raise ValueError('Unique compatible free-flowing head, explicit mass and evidence required')
i['state'].update({'head.loaded_id': head_id, 'truth.source_mass_kg': float(source_mass_kg)})
i['evidence']['head'] = evidence
i['revision'] += 1
def host_load_container(self, iid, *, container_id, position_id, content_mass_kg, evidence):
with self._lock:
i = self._idle(iid, True)
if not all(_qt_text(v) for v in (container_id, position_id, evidence)) or not _qt_number(content_mass_kg) or content_mass_kg < 0 or i['state']['container.loaded_id'] is not None or any(x['state']['container.loaded_id'] == container_id for x in self._instances.values()):
raise ValueError('Unique container, position, explicit nonnegative content mass and placement evidence required')
i['state'].update({'container.loaded_id': container_id, 'truth.container_mass_kg': float(content_mass_kg), 'balance.tared': False, 'truth.actual_dosed_kg': None, 'dosing.elapsed_s': 0.0, 'dosing.status': 'idle'})
i['position_id'], i['evidence']['container'] = position_id, evidence
self._refresh(i)
i['revision'] += 1
def host_configure_dosing(self, iid, *, rate_kg_s, rate_evidence, observation_evidence):
with self._lock:
i = self._idle(iid)
if not _qt_number(rate_kg_s) or rate_kg_s <= 0 or not _qt_text(rate_evidence) or not _qt_text(observation_evidence):
raise ValueError('Explicit positive rate and ideal-observation assumption evidence required')
i['rate_kg_s'] = float(rate_kg_s)
i['evidence'].update({'rate': rate_evidence, 'observation': observation_evidence})
i['state']['simulation.rate_configured'] = True
self._refresh(i)
i['revision'] += 1
def host_unload_container(self, iid):
with self._lock:
i = self._idle(iid, True)
s = i['state']
if s['container.loaded_id'] is None or s['container.attachment_constraint_id'] is not None:
raise ValueError('Loaded unattached container required')
result = {'container_id': s['container.loaded_id'], 'content_mass_kg': s['truth.container_mass_kg']}
s.update({'container.loaded_id': None, 'container.position_id': None, 'truth.container_mass_kg': None, 'balance.tared': False})
i['position_id'], i['tare_mass_kg'] = None, None
self._refresh(i)
i['revision'] += 1
return result
def host_unload_head(self, iid):
with self._lock:
i = self._idle(iid, True)
s = i['state']
if s['head.loaded_id'] is None:
raise ValueError('Loaded head required')
result = {'head_id': s['head.loaded_id'], 'source_mass_kg': s['truth.source_mass_kg']}
s.update({'head.loaded_id': None, 'head.selected_id': None, 'truth.source_mass_kg': None})
i['revision'] += 1
return result
def _attachment(self, iid, kind, constraint_id, adapter):
i = self._idle(iid, True)
s = i['state']
if s['container.loaded_id'] is None or not callable(adapter) or (kind == 'attach' and (not _qt_text(constraint_id) or s['container.attachment_constraint_id'] is not None or any(x['state']['container.attachment_constraint_id'] == constraint_id for x in self._instances.values()))) or (kind == 'release' and s['container.attachment_constraint_id'] is None):
raise ValueError('Loaded container, external adapter and valid unique attachment state required')
event = {'event': kind, 'instance_id': iid, 'container_id': s['container.loaded_id'], 'constraint_id': constraint_id if kind == 'attach' else s['container.attachment_constraint_id'], 'time_s': self.time_s, 'robot': 'absent'}
if adapter(iid, _qt_copy.deepcopy(event)) is not True:
raise RuntimeError('External attachment not confirmed; side effects unknown')
s['container.attachment_constraint_id'] = constraint_id if kind == 'attach' else None
i['revision'] += 1
self._events.append(_qt_copy.deepcopy(event))
return event
def host_attach(self, iid, *, constraint_id, attachment_adapter):
with self._lock:
return self._attachment(iid, 'attach', constraint_id, attachment_adapter)
def host_release(self, iid, *, attachment_adapter):
with self._lock:
return self._attachment(iid, 'release', None, attachment_adapter)
@staticmethod
def _result(i):
return {k: _qt_copy.deepcopy(i['state'][k]) for k in _QT_READ_IDS}
def _stop(self, i, status, code=None):
opid = i['active_operation']
i['state']['dosing.status'] = status
i['active_operation'] = None
if opid:
op = self._operations[opid]
op['status'], op['result'] = status, self._result(i)
if code is not None:
op['error'] = {'code':code,'message':'Source exhausted before reaching the requested target; transferred powder remains in the receiver.','retryable':False,'side_effects':'partial','progress':self._result(i)}
def host_step(self, dt_s, *, world_time_s):
with self._lock:
if not _qt_number(dt_s) or dt_s <= 0 or not _qt_number(world_time_s) or not _qt_number(self.time_s + dt_s) or not _qt_math.isclose(world_time_s, self.time_s + dt_s, rel_tol=0, abs_tol=1e-9):
raise ValueError('Finite positive step must match explicit common world time')
updates = []
for iid,i in self._instances.items():
if i['active_operation'] is None:
continue
s, rate = i['state'], i['rate_kg_s']
remaining = max(0.0, s['dosing.target_mass_kg'] - s['truth.actual_dosed_kg'])
amount = min(remaining, s['truth.source_mass_kg'], rate * dt_s)
if amount == 0 and remaining > 0 and s['truth.source_mass_kg'] > 0:
raise ValueError('Transfer below numerical resolution; no instance advanced')
elapsed = min(dt_s, amount / rate)
if not all(_qt_number(v) for v in [amount, elapsed, s['truth.container_mass_kg'] + amount, s['dosing.elapsed_s'] + elapsed]):
raise ValueError('Transfer would overflow; no instance advanced')
if amount > 0 and (s['truth.container_mass_kg'] + amount == s['truth.container_mass_kg'] or s['truth.source_mass_kg'] - amount == s['truth.source_mass_kg']):
raise ValueError('Mass change below numerical resolution; no instance advanced')
updates.append((iid, i, amount, elapsed))
for iid,i,amount,elapsed in updates:
s, opid = i['state'], i['active_operation']
s['truth.source_mass_kg'] -= amount
s['truth.container_mass_kg'] += amount
s['truth.actual_dosed_kg'] += amount
s['dosing.elapsed_s'] += elapsed
self._refresh(i)
if amount > 0:
self._ledger.append({'transaction_id': '%s_transfer_%d' % (opid,len(self._ledger)+1), 'operation_id': opid, 'instance_id': iid, 'donor_id': s['head.loaded_id'], 'receiver_id': s['container.loaded_id'], 'mass_kg': amount, 'unit': 'kg', 'time_s': self.time_s + elapsed})
if s['truth.actual_dosed_kg'] >= s['dosing.target_mass_kg']:
self._stop(i, 'succeeded')
elif s['truth.source_mass_kg'] <= 0:
self._stop(i, 'failed', 'SOURCE_DEPLETED')
self._operations[opid]['result'] = self._result(i)
i['revision'] += 1
self.time_s = float(world_time_s)
def host_transfer_ledger(self):
with self._lock:
return _qt_copy.deepcopy(self._ledger)
def debug_snapshot(self):
with self._lock:
return _qt_copy.deepcopy({'time_s': self.time_s, 'instances': {iid:{k:v for k,v in i.items() if k != 'adapter'} for iid,i in self._instances.items()}, 'operations': self._operations, 'ledger': self._ledger, 'events': self._events})
class QuantosQ2Session:
def __init__(self, host, principal_id):
self.__host, self.__principal = host, principal_id
def _get(self, iid):
return self.__host._get(iid, self.__principal)
def _visible(self, sid):
return isinstance(sid,str) and sid in _QT_SLOTS and (_QT_SLOTS[sid]['visibility'] == 'agent' or self.__host._principals[self.__principal][0] in ('debug','evaluator'))
def _response(self, iid, rid=None, status='succeeded', result=None, observations=None, operation_id=None, error=None):
i = self._get(iid)
return {'protocol_version':'1.0.0','instance_id':iid if isinstance(iid,str) else None,'request_id':rid if isinstance(rid,str) else None,'status':status,'operation_id':operation_id,'state_revision':i['revision'] if i else None,'clock':{'domain':'simulation','time_s':self.__host.time_s},'result':_qt_copy.deepcopy(result or {}),'observations':_qt_copy.deepcopy(observations or {}),'error':error}
def _error(self, iid, code, rid=None, status='rejected', side='none'):
return self._response(iid,rid,status,error={'code':code,'message':'Request does not satisfy declared access, input or operating conditions.','retryable':False,'side_effects':side,'progress':None})
def describe(self, *, asset_type_id=None, instance_id=None):
with self.__host._lock:
if (asset_type_id is None) == (instance_id is None) or (asset_type_id is not None and asset_type_id != QUANTOS_Q2_TYPE):
return self._error(instance_id,'INVALID_ARGUMENT')
i = self._get(instance_id) if instance_id is not None else None
if instance_id is not None and i is None:
return self._error(instance_id,'UNKNOWN_INSTANCE')
if self.__host._principals[self.__principal][1] == frozenset():
return self._error(instance_id,'ACCESS_DENIED')
data = export_quantos_q2_contract_metadata()
data.pop('host_api')
data['state_slots'] = {sid:v for sid,v in data['state_slots'].items() if self._visible(sid)}
for cap in data['capabilities'].values():
cap['state_effects'] = [e for e in cap['state_effects'] if self._visible(e['state_id'])]
if i is not None and i['adapter'] is None:
data['capabilities']['door.set_opening']['availability'] = 'unsupported'
data.update({'protocol_version':'1.0.0','instance_id':instance_id,'adapter':'basic40_runtime_automation.QuantosQ2Session'})
return data
def read(self, *, instance_id, state_ids=None):
with self.__host._lock:
i = self._get(instance_id)
if i is None:
return self._error(instance_id,'UNKNOWN_INSTANCE')
if state_ids is None:
state_ids = [sid for sid in _QT_SLOTS if self._visible(sid)]
if not isinstance(state_ids,list) or any(not isinstance(s,str) for s in state_ids) or len(set(state_ids)) != len(state_ids):
return self._error(instance_id,'INVALID_ARGUMENT')
if any(not self._visible(sid) for sid in state_ids):
return self._error(instance_id,'ACCESS_DENIED')
obs = {}
for sid in state_ids:
v = i['state'][sid]
obs[sid] = {'value':_qt_copy.deepcopy(v),'unit':_QT_SLOTS[sid]['unit'],'quality':'unavailable' if v is None else 'estimated' if sid.startswith('measurement.') or sid == 'scene.door_opening_m' else 'valid','sample_time_s':self.__host.time_s,'sample_window_s':None}
if v is None:
obs[sid]['reason'] = 'Explicit configuration, placement, balance tare or current powered observation is unavailable.'
return self._response(instance_id,observations=obs)
def _cached(self, iid, rid, logical, callback):
if not _qt_text(rid) or len(rid)>256:
return self._error(iid,'INVALID_ARGUMENT',rid)
try:
digest = _qt_json.dumps(logical, sort_keys=True, allow_nan=False, separators=(',',':'))
except (TypeError, ValueError, OverflowError, RecursionError):
return self._error(iid,'INVALID_ARGUMENT',rid)
key = (self.__principal,iid,rid)
if key in self.__host._requests:
prev, reply = self.__host._requests[key]
return _qt_copy.deepcopy(reply) if prev == digest else self._error(iid,'REQUEST_CONFLICT',rid)
response = callback()
self.__host._requests[key] = (digest,_qt_copy.deepcopy(response))
return response
def invoke(self, *, instance_id, capability_id, arguments, request_id):
with self.__host._lock:
i = self._get(instance_id)
if i is None:
return self._error(instance_id,'UNKNOWN_INSTANCE',request_id)
if not isinstance(capability_id,str) or not isinstance(arguments,dict):
return self._error(instance_id,'INVALID_ARGUMENT',request_id)
return self._cached(instance_id,request_id,['invoke',capability_id,arguments],lambda:self._execute(instance_id,i,capability_id,arguments,request_id))
def _execute(self, iid, i, cid, args, rid):
caps = export_quantos_q2_contract_metadata()['capabilities']
fail = lambda code:self._error(iid,code,rid)
if cid not in caps:
return fail('UNKNOWN_CAPABILITY')
cap = caps[cid]
props = cap['input_schema']['properties']
if set(args) != set(props):
return fail('INVALID_ARGUMENT')
for k,spec in props.items():
v = args[k]
if (spec['type']=='number' and (not _qt_number(v) or ('minimum' in spec and v<spec['minimum']) or ('maximum' in spec and v>spec['maximum']))) or (spec['type']=='boolean' and type(v) is not bool) or (spec['type']=='string' and not _qt_text(v)):
return fail('INVALID_ARGUMENT')
if cid == 'autosampler.advance':
return self._error(iid,'UNSUPPORTED',rid,'unsupported')
if cid == 'dosing.read':
return self._response(iid,rid,result=self.__host._result(i))
if cid in ('dosing.poll','dosing.cancel'):
op = self.__host._operations.get(args['operation_id'])
if op is None or op['instance_id'] != iid or op['principal'] != self.__principal:
return fail('UNKNOWN_OPERATION')
if cid == 'dosing.cancel' and op['status'] == 'running':
self.__host._stop(i,'cancelled')
i['revision'] += 1
return self._response(iid,rid,status=op['status'],operation_id=args['operation_id'],result=op['result'],error=op.get('error'))
s = i['state']
if i['active_operation'] is not None and not (cid == 'power.set' and args['enabled'] is False):
return fail('BUSY')
if cid not in ('power.set','door.set_opening') and not s['power.enabled']:
return fail('PRECONDITION_FAILED')
if cid == 'power.set':
s['power.enabled'] = args['enabled']
if not args['enabled']:
if i['active_operation'] is not None:
self.__host._stop(i,'cancelled')
s['balance.tared'] = False
elif cid == 'dosing.set_target':
s['dosing.target_mass_kg'] = float(args['target_mass_kg'])
elif cid == 'dosing.set_tolerance':
s['dosing.tolerance_kg'] = float(args['tolerance_kg'])
elif cid == 'head.select':
if args['head_id'] != s['head.loaded_id']:
return fail('PRECONDITION_FAILED')
s['head.selected_id'] = args['head_id']
elif cid == 'container.select_position':
if s['container.loaded_id'] is None or args['position_id'] != i['position_id']:
return fail('PRECONDITION_FAILED')
s['container.position_id'], s['balance.tared'] = args['position_id'], False
elif cid == 'door.set_opening':
if i['adapter'] is None:
return self._error(iid,'UNSUPPORTED',rid,'unsupported')
if i['door_travel_m'] is None:
return fail('PRECONDITION_FAILED')
if args['opening_m'] > i['door_travel_m']:
return fail('INVALID_ARGUMENT')
try:
confirmed = i['adapter'](iid, {'scene.door_opening_m':float(args['opening_m'])}) is True
except Exception:
confirmed = False
if not confirmed:
return self._error(iid,'DEVICE_ERROR',rid,'failed','unknown')
s['scene.door_opening_m'] = float(args['opening_m'])
if args['opening_m'] > 0:
s['balance.tared'] = False
elif cid == 'balance.tare':
if s['scene.door_opening_m'] != 0 or s['container.loaded_id'] is None or s['container.position_id'] != i['position_id'] or not s['simulation.rate_configured']:
return fail('PRECONDITION_FAILED')
i['tare_mass_kg'], s['balance.tared'] = s['truth.container_mass_kg'], True
elif cid == 'dosing.start':
if not s['balance.tared'] or s['scene.door_opening_m'] != 0 or s['dosing.target_mass_kg'] is None or s['dosing.tolerance_kg'] is None or s['head.loaded_id'] is None or s['head.selected_id'] != s['head.loaded_id'] or s['container.loaded_id'] is None or s['container.position_id'] != i['position_id'] or i['rate_kg_s'] is None or s['truth.source_mass_kg'] <= 0 or s['container.attachment_constraint_id'] is not None:
return fail('PRECONDITION_FAILED')
# A new cycle requires a tare at the current container mass; it cannot silently reuse a previous dose baseline.
if i['tare_mass_kg'] != s['truth.container_mass_kg']:
return fail('PRECONDITION_FAILED')
s.update({'dosing.status':'running','dosing.elapsed_s':0.0,'truth.actual_dosed_kg':0.0})
self.__host._counter += 1
opid = 'qt_op_%d' % self.__host._counter
i['active_operation'] = opid
self.__host._refresh(i)
op = {'instance_id':iid,'principal':self.__principal,'status':'running','result':self.__host._result(i)}
self.__host._operations[opid] = op
i['revision'] += 1
return self._response(iid,rid,'accepted',result=op['result'],operation_id=opid)
self.__host._refresh(i)
i['revision'] += 1
return self._response(iid,rid,result={sid:s[sid] for sid in cap['observes']})
def write(self, *, instance_id, state_id, value, request_id):
with self.__host._lock:
if self._get(instance_id) is None:
return self._error(instance_id,'UNKNOWN_INSTANCE',request_id)
if not self._visible(state_id) or _QT_SLOTS[state_id]['write_via'] is None:
return self._error(instance_id,'ACCESS_DENIED',request_id)
via = _QT_SLOTS[state_id]['write_via']
return self.invoke(instance_id=instance_id,capability_id=via['capability_id'],arguments={via['parameter']:value},request_id=request_id)
def poll(self, *, instance_id, operation_id):
with self.__host._lock:
i = self._get(instance_id)
if i is None:
return self._error(instance_id,'UNKNOWN_INSTANCE')
return self._execute(instance_id,i,'dosing.poll',{'operation_id':operation_id},None)
def cancel(self, *, instance_id, operation_id, request_id):
return self.invoke(instance_id=instance_id,capability_id='dosing.cancel',arguments={'operation_id':operation_id},request_id=request_id)
# END CHEM-174 QUANTOS Q2 XPE206DR APPEND-ONLY RUNTIME
# CHEM-176 canonical contract state IDs are lowercase; preserve legacy SI-suffix labels.
_AHS_CONTRACT_STATE_ALIASES = {sid.lower(): sid for sid in _AHS_SLOTS}
_ahs_session_read_legacy = AzentaHeatSealerSession.read
_ahs_session_write_legacy = AzentaHeatSealerSession.write
_ahs_session_describe_legacy = AzentaHeatSealerSession.describe
def _ahs_session_read_contract(self, *, instance_id, state_ids=None):
if state_ids is None or not isinstance(state_ids, list) or any(not isinstance(sid,str) for sid in state_ids):
return _ahs_session_read_legacy(self, instance_id=instance_id, state_ids=state_ids)
actual = [_AHS_CONTRACT_STATE_ALIASES.get(sid,sid) for sid in state_ids]
response = _ahs_session_read_legacy(self, instance_id=instance_id, state_ids=actual)
if response['status'] == 'succeeded':
response['observations'] = {requested: _ahs_copy.deepcopy(response['observations'][source]) for requested,source in zip(state_ids,actual)}
return response
def _ahs_session_write_contract(self, *, instance_id, state_id, value, request_id):
actual = _AHS_CONTRACT_STATE_ALIASES.get(state_id,state_id) if isinstance(state_id,str) else state_id
return _ahs_session_write_legacy(self, instance_id=instance_id, state_id=actual, value=value, request_id=request_id)
def _ahs_session_describe_contract(self, *, asset_type_id=None, instance_id=None):
metadata = _ahs_session_describe_legacy(self, asset_type_id=asset_type_id, instance_id=instance_id)
if 'state_slots' in metadata:
metadata['state_slots'] = {sid.lower():slot for sid,slot in metadata['state_slots'].items()}
for cap in metadata['capabilities'].values():
cap['observes'] = [sid.lower() for sid in cap['observes']]
for effect in cap['state_effects']: effect['state_id'] = effect['state_id'].lower()
metadata['limitations'].append('合同状态ID采用小写_k/_k_s；显式read/write接受这些规范ID。省略state_ids的旧便捷read保留原实现的SI后缀标签；标准lab.read应显式传入合同状态ID。')
return metadata
AzentaHeatSealerSession.read = _ahs_session_read_contract
AzentaHeatSealerSession.write = _ahs_session_write_contract
AzentaHeatSealerSession.describe = _ahs_session_describe_contract
# BEGIN CHEM-174 QUANTOS STRICT COMMON-CLOCK PROGRESSION
# Preserve the existing implementation while rejecting a positive dt that is
# below the representable resolution of the current floating-point clock.
_qt_host_step_before_clock_resolution_check = QuantosQ2Runtime.host_step
def _qt_host_step_with_clock_resolution_check(self, dt_s, *, world_time_s):
with self._lock:
if _qt_number(dt_s) and _qt_number(world_time_s) and dt_s > 0 and (
world_time_s <= self.time_s or self.time_s + dt_s <= self.time_s):
raise ValueError('A positive transfer step must strictly advance the representable common world clock')
return _qt_host_step_before_clock_resolution_check(self, dt_s, world_time_s=world_time_s)
QuantosQ2Runtime.host_step = _qt_host_step_with_clock_resolution_check
# END CHEM-174 QUANTOS STRICT COMMON-CLOCK PROGRESSION
# BEGIN CHEM-175 OPENTRONS FLEX DECIMAL LEDGER REVIEW PATCH
# Additive patch: retain every previously published instrument block verbatim.
import decimal as _flex_decimal
_flex_apply_before_decimal_review = OpentronsFlexRuntime._apply
def _flex_apply_decimal_review(self, item, iid, cid, args, rid):
if cid not in ('sample.aspirate', 'sample.dispense'):
return _flex_apply_before_decimal_review(self, item, iid, cid, args, rid)
state = item['state']
fail = lambda: self._response(iid, rid, status='rejected', code='PRECONDITION_FAILED')
container = item['containers'].get(args['container_id'])
tip_id = state['tip.attached_id']
if (not state['power.enabled'] or container is None or tip_id is None
or container['slot_id'] not in OPENTRONS_FLEX_WORK_SLOTS
or not self._position_matches(self._position(item), container['position_m'])):
return fail()
tip = item['tips'][tip_id]
donor, receiver = (container, tip) if cid == 'sample.aspirate' else (tip, container)
# Canonical decimal SI values eliminate cumulative binary roundoff at the
# specified 5 uL and 1000 uL bounds. Wire observations remain JSON numbers.
with _flex_decimal.localcontext() as context:
context.prec = 700
dec = _flex_decimal.Decimal
volume = dec(str(args['volume_m3']))
donor_before = dec(str(donor['volume_m3']))
receiver_before = dec(str(receiver['volume_m3']))
receiver_capacity = dec(str(receiver['capacity_m3']))
if donor_before < volume or receiver_capacity - receiver_before < volume:
return fail()
donor_after = float(donor_before - volume)
receiver_after = float(receiver_before + volume)
# A huge host inventory can make a microvolume change unrepresentable in
# the JSON-number state. Reject that case instead of claiming a transfer.
if donor_after == donor['volume_m3'] or receiver_after == receiver['volume_m3']:
return fail()
donor['volume_m3'], receiver['volume_m3'] = donor_after, receiver_after
sequence = state['sample.transfer_count'] + 1
state['truth.transfers'].append({'transaction_id': '%s.transfer.%d' % (iid, sequence),
'donor_id': donor.get('container_id', donor.get('tip_id')),
'receiver_id': receiver.get('container_id', receiver.get('tip_id')),
'volume_m3': float(volume), 'unit': 'm^3', 'kind': cid.split('.')[1], 'time_s': self.time_s})
state['sample.transfer_count'] = sequence
self._sync_inventory(item)
item['revision'] += 1
return self._response(iid, rid, result={'sample.transfer_count': sequence})
OpentronsFlexRuntime._apply = _flex_apply_decimal_review
_FLEX_SLOTS['truth.tips']['value_schema']['items']['properties']['position_m']['description'] = 'Last host-registered pickup or release target in joint coordinates. While attached, the tip follows motion.x_m/y_m/z_m; this stored target is not a live tool pose.'
_flex_metadata_before_decimal_review = export_opentrons_flex_contract_metadata
def export_opentrons_flex_contract_metadata():
metadata = _flex_metadata_before_decimal_review()
metadata['limitations'].append('体积转移用十进制SI算术后输出JSON浮点数，避免5 µL累积到1000 µL的边界误拒绝；若宿主登记的极大库存使本次微量变化在输出数值中不可分辨，则拒绝且不提交。')
metadata['limitations'].append('truth.tips中的position_m保存最后登记的拾取或释放目标；吸头附着后的实时位姿跟随motion.*，不把旧槽位坐标当作实时工具位置。')
for cid in ('sample.aspirate', 'sample.dispense'):
metadata['capabilities'][cid]['preconditions_zh'].append('供受体转移后的JSON数值须均可分辨本次变化；不支持极大库存上的不可分辨微量转移')
return metadata
# END CHEM-175 OPENTRONS FLEX DECIMAL LEDGER REVIEW PATCH
# CHEM-175 review wording: public discovery must not enumerate private slot IDs.
_flex_metadata_before_public_review_wording = export_opentrons_flex_contract_metadata
def export_opentrons_flex_contract_metadata():
metadata = _flex_metadata_before_public_review_wording()
metadata['limitations'] = [text.replace('truth.tips中的position_m', '调试用吸头记录中的position_m') for text in metadata['limitations']]
return metadata
# BEGIN CHEM-178 PRECISEFLEX 400 APPEND-ONLY RUNTIME
import copy as _pf400_copy
import json as _pf400_json
import math as _pf400_math
import threading as _pf400_threading
PRECISEFLEX400_TYPE = 'instrument.brooks_preciseflex_400'
def _pf400_number(value):
try:
return type(value) in (int, float) and _pf400_math.isfinite(value)
except (TypeError, OverflowError):
return False
def _pf400_text(value):
return isinstance(value, str) and bool(value.strip())
def _pf400_num(unit, lower=None, upper=None):
result = {'type': 'number', 'x-unit': unit}
if lower is not None:
result['minimum'] = lower
if upper is not None:
result['maximum'] = upper
return result
def _pf400_obj(properties):
return {'type': 'object', 'properties': properties, 'required': list(properties), 'additionalProperties': False}
def _pf400_nullable(schema):
return {'anyOf': [schema, {'type': 'null'}]}
def _pf400_matches(value, schema):
if 'anyOf' in schema:
return any(_pf400_matches(value, s) for s in schema['anyOf'])
kind = schema.get('type')
if kind == 'number':
if not _pf400_number(value) or ('minimum' in schema and value < schema['minimum']) or ('maximum' in schema and value > schema['maximum']):
return False
elif kind == 'integer':
if type(value) is not int or ('minimum' in schema and value < schema['minimum']):
return False
elif kind == 'boolean':
if type(value) is not bool:
return False
elif kind == 'string':
if not _pf400_text(value):
return False
elif kind == 'null':
return value is None
elif kind == 'object':
if not isinstance(value, dict) or set(value) != set(schema['properties']):
return False
if any(not _pf400_matches(value[k], spec) for k, spec in schema['properties'].items()):
return False
elif kind == 'array':
if not isinstance(value, list) or any(not _pf400_matches(v, schema['items']) for v in value):
return False
else:
return False
return 'enum' not in schema or value in schema['enum']
# Joint ranges: Rev B indexed specification, standard arm with servo gripper.
# Detailed proxy dimensions below are authored assumptions, NOT measured link lengths.
_PF400_JOINT_LIMITS = {'z_m': (0.0, 0.4),
'shoulder_rad': (-_pf400_math.radians(93), _pf400_math.radians(93)),
'elbow_rad': (-_pf400_math.radians(168), _pf400_math.radians(168)),
'wrist_rad': (-_pf400_math.radians(960), _pf400_math.radians(960))}
_PF400_GEOMETRY = {'shoulder_x_m': 0.0, 'shoulder_y_m': 0.0,
'upper_arm_m': 0.25, 'forearm_m': 0.25, 'tcp_z_home_m': 0.20,
'tool_offset_local_m': {'x_m': 0.079, 'y_m': 0.0, 'z_m': 0.0},
'tool_aabb_local_m': {'x_m': [-0.099, 0.021], 'y_m': [-0.07, 0.07], 'z_m': [-0.04, 0.04]},
'evidence': 'assumption',
'evidence_zh': '用于本批次代理模型的显式几何假设；0.25+0.25+0.079 m的全伸TCP符合表内0.579 m水平伸距，不代表原厂连杆尺寸。真实连杆尺寸未可靠取得并保持null。'}
def _pf400_joint_schema():
return _pf400_obj({k: _pf400_num('m' if k == 'z_m' else 'rad', *limits) for k, limits in _PF400_JOINT_LIMITS.items()})
_PF400_POS = _pf400_obj({k: _pf400_num('m') for k in ('x_m', 'y_m', 'z_m')})
_PF400_AABB = _pf400_obj({'min_m': _PF400_POS, 'max_m': _PF400_POS})
_PF400_TEXT = {'type': 'string', 'minLength': 1}
_PF400_BOOL = {'type': 'boolean'}
_PF400_EVENT = _pf400_obj({'event': {'type': 'string', 'enum': ['attach', 'release']},
'container_id': _PF400_TEXT, 'constraint_id': _PF400_TEXT, 'port_id': _PF400_TEXT,
'time_s': _pf400_num('s', 0), 'constraint_authority': {'type': 'string', 'enum': ['host']},
'robot': {'type': 'string', 'enum': ['absent']}})
def preciseflex400_forward_kinematics(joints):
"""Pure FK for the authored, explicitly evidenced geometry; does not move time or scene."""
if not _pf400_matches(joints, _pf400_joint_schema()):
raise ValueError('Four finite joints inside their declared SI limits are required')
q = {k: float(v) for k, v in joints.items()}
g = _PF400_GEOMETRY
shoulder = q['shoulder_rad']
elbow = shoulder + q['elbow_rad']
yaw = elbow + q['wrist_rad']
p = {'x_m': g['shoulder_x_m'] + g['upper_arm_m'] * _pf400_math.cos(shoulder) + g['forearm_m'] * _pf400_math.cos(elbow),
'y_m': g['shoulder_y_m'] + g['upper_arm_m'] * _pf400_math.sin(shoulder) + g['forearm_m'] * _pf400_math.sin(elbow),
'z_m': g['tcp_z_home_m'] + q['z_m']}
offset = g['tool_offset_local_m']
p['x_m'] += offset['x_m'] * _pf400_math.cos(yaw) - offset['y_m'] * _pf400_math.sin(yaw)
p['y_m'] += offset['x_m'] * _pf400_math.sin(yaw) + offset['y_m'] * _pf400_math.cos(yaw)
# tcp_z_home_m includes the fixed local tool Z offset; rotation axes are all +Z.
points = []
for x in g['tool_aabb_local_m']['x_m']:
for y in g['tool_aabb_local_m']['y_m']:
for z in g['tool_aabb_local_m']['z_m']:
points.append((p['x_m'] + x * _pf400_math.cos(yaw) - y * _pf400_math.sin(yaw),
p['y_m'] + x * _pf400_math.sin(yaw) + y * _pf400_math.cos(yaw), p['z_m'] + z))
bounds = {name: {key: func(v[n] for v in points) for n, key in enumerate(('x_m', 'y_m', 'z_m'))}
for name, func in (('min_m', min), ('max_m', max))}
return {'joints': q, 'tcp_position_m': p, 'tool_yaw_rad': yaw, 'end_effector_aabb_m': bounds}
def _pf400_slots():
def slot(schema, unit, origin, via=None, parameter=None, visibility='agent'):
return {'value_schema': schema, 'unit': unit, 'origin': origin, 'visibility': visibility,
'access': 'read_write' if via else 'read_only', 'reference_conditions': 'Authored base frame; right-handed, +Z upward; SI.' if unit in ('m', 'rad') else None,
'write_via': {'capability_id': via, 'parameter': parameter, 'fixed_arguments': {}} if via else None,
'sampling': {'mode': 'instant', 'time_domain': 'simulation', 'window': None}}
result = {
'power.enabled': slot(_PF400_BOOL, '1', 'setpoint', 'power.set', 'enabled'),
'motion.target_joints': slot(_pf400_nullable(_pf400_joint_schema()), '1', 'setpoint', 'motion.set_joints', 'joints'),
'motion.status': slot({'type': 'string', 'enum': ['uninitialized', 'ready', 'target_pending', 'fault']}, '1', 'derived'),
'scene.joints': slot(_pf400_nullable(_pf400_joint_schema()), '1', 'scene'),
'scene.tcp_position_m': slot(_pf400_nullable(_PF400_POS), 'm', 'scene'),
'scene.tool_yaw_rad': slot(_pf400_nullable(_pf400_num('rad')), 'rad', 'scene'),
'scene.end_effector_aabb_m': slot(_pf400_nullable(_PF400_AABB), 'm', 'scene'),
'scene.sample_time_s': slot(_pf400_nullable(_pf400_num('s', 0)), 's', 'scene'),
'sample.attached_container_id': slot(_pf400_nullable(_PF400_TEXT), '1', 'scene'),
'sample.constraint_id': slot(_pf400_nullable(_PF400_TEXT), '1', 'scene'),
'sample.events': slot({'type': 'array', 'items': _PF400_EVENT}, '1', 'scene'),
'sample.container_ids': slot({'type': 'array', 'items': _PF400_TEXT}, '1', 'scene'),
'sample.receiver_port_ids': slot({'type': 'array', 'items': _PF400_TEXT}, '1', 'scene'),
'host.scene_bound': slot(_PF400_BOOL, '1', 'derived'),
'truth.registered_payloads': slot({'type': 'array', 'items': _pf400_obj({'container_id': _PF400_TEXT, 'gross_payload_kg': _pf400_nullable(_pf400_num('kg', 0))})}, '1', 'process_truth', visibility='debug'),
}
for sid, s in result.items():
s['read_binding'] = 'PreciseFlex400Session.read(instance_id=..., state_ids=[%r])' % sid
result['motion.target_joints']['reference_conditions'] = result['scene.joints']['reference_conditions'] = 'Mixed joint object: z_m in m; shoulder_rad, elbow_rad, wrist_rad in rad; positive +Z translation and right-handed +Z rotations.'
return result
_PF400_LIMITATIONS = [
'目标关节写入是同步设定，不表示实际运动完成。可信宿主提供共同时间并通过求值场景回调确认关节、TCP与末端包围盒。没有轨迹、动力学或碰撞规避。',
'典型TCP速度0.5 m/s、最大加速度2 m/s²、重复定位±90 µm只作为整机证据，不推导各关节速度、部件误差、碰撞或运动时长。',
'attach/release由预注册宿主约束回调执行；容器、端口、位置容差、gross payload及证据由宿主明确登记；没有接触抓取、夹爪力、摩擦或硬件驱动。',
'清单Rev B原文为with Servo Gripper的0.5 kg负载；不同文档版本的口径仍需按实物配置核验。gross_payload_kg保守记录容器、内容物、额外夹具，以及宿主按配置计入的末端工具总外载；宿主必须明确提供，未给则null且不可attach。本模拟不授予实机载荷使用许可。',
'J1范围0..0.4 m，J2±93°、J3±168°、J4±960°来自Rev B网页索引；直接PDF失效，图纸尺寸尚未可靠取得。两段0.25 m连杆和0.079 m腕到TCP偏置是明确的代理几何假设，真实部件尺寸仍为null。',
'目标位姿通过有界关节目标与正运动学表达；尚无逆运动学、任务队列调度、原厂设备握手协议或可执行的TCP速度设定。宿主求值与约束回执仅为本仿真适配接口。',
'样品拓扑仅搬运完整容器；不改变内容物或推断其组成。容器/端口唯一性与跨仪器约束一致性由外层世界注册表保证。',
'本模块无气路端口。整机20 kg与0.5 kg额定负载不能代替连杆质量、惯量、夹具重量或材料参数；未知属性保持null。',
'回调异常后外部副作用未知，motion.status=fault阻止重复附着和移动；只能由可信宿主在外部状态核实后恢复。',
'身份来自可信宿主；API过滤不是Python或共享文件系统隔离。请求去重仅当前进程内存有效。',
]
def export_preciseflex400_contract_metadata():
slots = _pf400_slots()
public = [sid for sid, s in slots.items() if s['visibility'] == 'agent']
specs = {
'power.set': ({'enabled': _PF400_BOOL}, ['power.enabled'], ['power.enabled'], {'enabled': True}, ['controller'], '设置运行层供电状态；断电保留关节、待执行目标及已有约束。'),
'motion.set_joints': ({'joints': _pf400_joint_schema()}, ['motion.target_joints', 'motion.status'], ['motion.target_joints', 'motion.status'], {'joints': {k: 0.0 for k in _PF400_JOINT_LIMITS}}, ['lift', 'upper_arm', 'forearm', 'wrist'], '检查关节限位并同步写目标；宿主场景确认前实际姿态不变。'),
'motion.forward_kinematics': ({'joints': _pf400_joint_schema()}, [], [], {'joints': {k: 0.0 for k in _PF400_JOINT_LIMITS}}, ['upper_arm', 'forearm', 'wrist', 'gripper'], '查询目标关节对应的TCP、偏航及末端几何包围盒，不写状态或推进时间。'),
'state.read': ({}, [], public, {}, ['controller'], '读取允许观测的统一状态快照，不推进共同时间。'),
'sample.attach': ({'container_id': _PF400_TEXT, 'constraint_id': _PF400_TEXT}, ['sample.attached_container_id', 'sample.constraint_id', 'sample.events', 'motion.status'], ['sample.attached_container_id', 'sample.constraint_id', 'sample.events'], {'container_id': 'host_container', 'constraint_id': 'host_constraint'}, ['gripper'], '已登记容器、已登记约束、端口位置与负载检查通过后，调用宿主attach约束并记录明确回执。'),
'sample.release': ({'receiver_port_id': _PF400_TEXT}, ['sample.attached_container_id', 'sample.constraint_id', 'sample.events', 'motion.status'], ['sample.attached_container_id', 'sample.constraint_id', 'sample.events'], {'receiver_port_id': 'host_receiver'}, ['gripper'], '在已登记接收端口调用宿主release约束，确认后登记容器拓扑与事件。'),
'robot.contact_grasp': ({}, [], [], {}, ['gripper'], '接触抓取、机器人规划和真实夹爪驱动未实现。'),
'motion.set_tcp_velocity': ({'velocity_m_s': _pf400_num('m/s', 0)}, [], [], {'velocity_m_s': 0.1}, ['controller'], '无轨迹执行器，典型整机TCP速度不作为可执行的速度设定。'),
}
caps = {}
for cid, (props, effects, observed, example, components, description) in specs.items():
unsupported = cid in ('robot.contact_grasp', 'motion.set_tcp_velocity')
attach = cid in ('sample.attach', 'sample.release')
output = _pf400_obj({sid: _pf400_copy.deepcopy(slots[sid]['value_schema']) for sid in observed})
if cid == 'motion.forward_kinematics':
output = _pf400_obj({'joints': _pf400_joint_schema(), 'tcp_position_m': _PF400_POS, 'tool_yaw_rad': _pf400_num('rad'), 'end_effector_aabb_m': _PF400_AABB})
prereq = []
if cid == 'motion.set_joints':
prereq = ['供电、场景回调已注册且当前已确认姿态；不处于fault；目标各关节满足独立有限区间。']
elif attach:
prereq = ['供电、motion.status=ready、场景姿态时间等于当前宿主时钟。', '容器、端口及约束由可信宿主注册；当前位置落在显式容差内；attach时gross payload必须已知且≤0.5 kg；回调仅返回True才确认。']
caps[cid] = {'name_zh': description, 'description_zh': description,
'kind': 'query' if cid in ('state.read', 'motion.forward_kinematics') else 'robot_skill' if cid == 'robot.contact_grasp' else 'device_command',
'visibility': 'agent', 'availability': 'unsupported' if unsupported else 'implemented', 'component_ids': components,
'input_schema': _pf400_obj(_pf400_copy.deepcopy(props)), 'output_schema': output, 'observes': observed,
'state_effects': [{'state_id': sid, 'timing': 'immediate', 'description_zh': '按已验证条件更新；外部回调异常时仅fault状态改变，外部副作用unknown。' if sid == 'motion.status' and attach else '当前调用同步更新该状态。'} for sid in effects],
'preconditions_zh': prereq, 'example_arguments': [_pf400_copy.deepcopy(example)],
'binding': None if unsupported else 'basic40_runtime_automation.PreciseFlex400Session.invoke(instance_id=..., capability_id=%r, arguments=..., request_id=...)' % cid,
'implementation': {'process': 'absent' if unsupported else 'implemented', 'scene': 'implemented' if attach else 'not_applicable', 'robot': 'absent', 'hardware': 'absent', 'host': 'absent' if unsupported else 'implemented'},
'model_effects': {'mode': 'host_required' if attach else 'none', 'binding_ids': [], 'description_zh': '可信宿主完成容器与夹爪外部约束；无接触求解。' if attach else '目标写入、纯FK与状态读取不直接修改几何；host_commit_pose独立确认实际模型求值。'},
'execution_notes': {'mode': 'synchronous', 'time_domain': 'simulation', 'cancellable': False, 'completion_zh': 'succeeded只确认设定目标已写入；实际姿态由host_commit_pose确认。' if cid == 'motion.set_joints' else '宿主约束回调明确True且事件已登记。' if attach else '返回所声明result；不推进时间。', 'partial_failure_zh': '回调失败外部副作用unknown；置fault并保留现有登记，禁止自动重放。其他拒绝不改变状态。', 'retry_zh': '身份、实例、request_id相同且参数相同返回原响应，参数不同拒绝；无跨重启保证。'},
'errors': [{'code': c, 'description_zh': d, 'side_effects': side} for c, d, side in [
('INVALID_ARGUMENT', '参数类型、范围或额外字段错误。', 'none'), ('UNKNOWN_INSTANCE', '实例不在身份允许范围。', 'none'), ('UNKNOWN_CAPABILITY', '能力不存在。', 'none'), ('ACCESS_DENIED', '状态不可写或不可读。', 'none'), ('PRECONDITION_FAILED', '供电、姿态、拓扑、约束或载荷条件不满足。', 'none'), ('BUSY', '外部回调执行期间拒绝重入写入。', 'none'), ('REQUEST_CONFLICT', '同一请求ID参数不一致。', 'none'), ('UNSUPPORTED', '没有本项执行器。', 'none'), ('DEVICE_ERROR', '外部约束回调未确认；fault已登记。', 'unknown')]]}
return {'asset_type_id': PRECISEFLEX400_TYPE, 'asset_version': '1.0.1', 'catalog_id': 'CHEM-178', 'state_slots': slots, 'capabilities': caps,
'kinematics': {'joint_limits': _pf400_copy.deepcopy(_PF400_JOINT_LIMITS), 'joint_limit_evidence_zh': 'PreciseFlex 400 Rev B网页索引；标准臂带servo gripper配置，完整尺寸图未可靠取得。', 'geometry': _pf400_copy.deepcopy(_PF400_GEOMETRY), 'direction_zh': 'z_m沿+Z；三个角关节按局部+Z右手正向（从上看逆时针）；代理零位全伸+X；FK x,y在台面固定基座坐标系。', 'scene_targets': {'z_m': 'pf400__j1_z.location.z', 'shoulder_rad': 'pf400__j2_shoulder.rotation_euler.z', 'elbow_rad': 'pf400__j3_elbow.rotation_euler.z', 'wrist_rad': 'pf400__j4_wrist.rotation_euler.z', 'tcp': 'pf400__tcp.matrix_world'}},
'parameters': {k: {'value': v, 'unit': u, 'evidence': e} for k, v, u, e in [('z_travel_m', .4, 'm', 'catalog'), ('horizontal_reach_m', .579, 'm', 'catalog'), ('rated_payload_kg', .5, 'kg', 'catalog'), ('whole_machine_mass_kg', 20.0, 'kg', 'catalog'), ('typical_tcp_speed_m_s', .5, 'm/s', 'catalog'), ('maximum_tcp_acceleration_m_s2', 2.0, 'm/s^2', 'catalog'), ('repeatability_m', .00009, 'm', 'catalog'), ('manufacturer_upper_arm_length_m', None, 'm', 'unknown'), ('manufacturer_forearm_length_m', None, 'm', 'unknown'), ('manufacturer_wrist_to_tcp_offset_m', None, 'm', 'unknown'), ('link_mass_kg', None, 'kg', 'unknown'), ('link_inertia_kg_m2', None, 'kg*m^2', 'unknown'), ('gripper_force_N', None, 'N', 'unknown'), ('contact_friction', None, '1', 'unknown'), ('joint_speed_limits_rad_s', None, 'rad/s', 'unknown')]},
'host_api': {name: {'entrypoint': 'PreciseFlex400Runtime.' + name, 'description_zh': desc} for name, desc in {
'create_instance': '创建独立实例，未确认的实际姿态、目标与载荷均为空。', 'register_principal': '由可信宿主固定身份与实例范围。', 'host_register_scene_adapter': '注册实际求值场景回调；返回joints、TCP、偏航与末端AABB。', 'host_set_clock': '明确共同世界时间，只接受非递减有限秒值；不会自行运动。', 'host_commit_pose': '给定关节与共同时间，回调求值结果与独立FK一致才提交；已有目标必须匹配。', 'host_register_container': '明确样品容器及源端口、位置、位置容差、总负载和证据；不执行抓取。', 'host_register_receiver_port': '登记外部样品接收端口及明确的位置容差。', 'host_register_constraint': '为已登记容器预注册唯一约束ID及attach/release回调。', 'host_reconcile_fault': '外部状态人工核实后恢复；记录宿主提供的真实附着结果，再重新确认姿态。'}.items()},
'limitations': list(_PF400_LIMITATIONS), 'output_schema_scope': 'capabilities.output_schema validates response.result; debug payload/evidence never appears in agent response'}
class PreciseFlex400Runtime:
"""Trusted simulation host. Only authenticated Session objects belong in agent tools."""
def __init__(self):
self.time_s = 0.0
self._instances, self._principals, self._requests = {}, {}, {}
self._lock = _pf400_threading.RLock()
self._callback_active = False
def _assert_mutable(self):
if self._callback_active:
raise ValueError('Host mutation is forbidden during an external callback')
def create_instance(self, instance_id):
with self._lock:
self._assert_mutable()
if not _pf400_text(instance_id) or instance_id in self._instances:
raise ValueError('Unique nonempty instance ID required')
state = {sid: None for sid in _pf400_slots()}
state.update({'power.enabled': False, 'motion.status': 'uninitialized', 'sample.events': [], 'sample.container_ids': [], 'sample.receiver_port_ids': [], 'host.scene_bound': False, 'truth.registered_payloads': []})
self._instances[instance_id] = {'state': state, 'revision': 0, 'scene_adapter': None, 'containers': {}, 'receivers': {}, 'constraints': {}, 'evidence': {}}
def register_principal(self, principal_id, *, visibility, instance_ids=None):
with self._lock:
self._assert_mutable()
if not _pf400_text(principal_id) or principal_id in self._principals or visibility not in ('agent', 'debug', 'evaluator'):
raise ValueError('Unique host-assigned identity and valid visibility required')
if instance_ids is not None and (not isinstance(instance_ids, (list, tuple, set, frozenset)) or any(not isinstance(i, str) or i not in self._instances for i in instance_ids)):
raise ValueError('Invalid instance scope')
self._principals[principal_id] = (visibility, None if instance_ids is None else frozenset(instance_ids))
def session(self, principal_id):
if not isinstance(principal_id, str) or principal_id not in self._principals:
raise ValueError('Host authentication required')
return PreciseFlex400Session(self, principal_id)
def _get(self, iid, principal=None):
p = self._principals.get(principal) if principal is not None else None
if not isinstance(iid, str) or (principal is not None and (p is None or (p[1] is not None and iid not in p[1]))):
return None
return self._instances.get(iid)
def _required(self, iid):
i = self._get(iid)
if i is None:
raise ValueError('Known instance required')
return i
def host_register_scene_adapter(self, instance_id, adapter):
with self._lock:
self._assert_mutable()
i = self._required(instance_id)
if not callable(adapter) or i['scene_adapter'] is not None:
raise ValueError('One callable scene authority per instance required')
i['scene_adapter'] = adapter
i['state']['host.scene_bound'] = True
i['revision'] += 1
def host_set_clock(self, world_time_s):
with self._lock:
self._assert_mutable()
if not _pf400_number(world_time_s) or world_time_s < self.time_s:
raise ValueError('Nondecreasing finite common world time required')
self.time_s = float(world_time_s)
@staticmethod
def _pose_matches(actual, expected):
if type(actual) is not dict or set(actual) != set(expected):
return False
for k, v in expected.items():
if isinstance(v, dict):
if not PreciseFlex400Runtime._pose_matches(actual[k], v):
return False
elif not _pf400_number(actual[k]) or not _pf400_math.isclose(actual[k], v, rel_tol=0, abs_tol=2e-6 if k.endswith('_rad') else 3e-7):
return False
return True
def host_commit_pose(self, instance_id, *, joints, world_time_s):
with self._lock:
self._assert_mutable()
i = self._required(instance_id)
s = i['state']
expected = preciseflex400_forward_kinematics(joints)
if not _pf400_number(world_time_s) or world_time_s < self.time_s or i['scene_adapter'] is None or s['motion.status'] == 'fault':
raise ValueError('Scene authority, nondecreasing world time and reconciled state required')
if s['motion.target_joints'] is not None and joints != s['motion.target_joints']:
raise ValueError('Committed pose must equal the currently requested target')
self._callback_active = True
try:
actual = i['scene_adapter'](instance_id, _pf400_copy.deepcopy(expected))
confirmed = self._pose_matches(actual, expected)
except Exception:
confirmed = False
finally:
self._callback_active = False
if not confirmed:
s['motion.status'] = 'fault'
i['revision'] += 1
raise RuntimeError('Evaluated scene pose mismatch; external side effects unknown; host reconciliation required')
s.update({'scene.joints': expected['joints'], 'scene.tcp_position_m': expected['tcp_position_m'], 'scene.tool_yaw_rad': expected['tool_yaw_rad'], 'scene.end_effector_aabb_m': expected['end_effector_aabb_m'], 'scene.sample_time_s': float(world_time_s), 'motion.status': 'ready'})
self.time_s = float(world_time_s)
i['revision'] += 1
@staticmethod
def _port(position_m, tolerance_m, evidence):
if not _pf400_matches(position_m, _PF400_POS) or not _pf400_number(tolerance_m) or tolerance_m <= 0 or not _pf400_text(evidence):
raise ValueError('Explicit finite position, positive geometric tolerance and evidence required')
return {'position_m': _pf400_copy.deepcopy(position_m), 'tolerance_m': float(tolerance_m), 'evidence': evidence}
def host_register_container(self, instance_id, container_id, *, source_port_id, position_m, tolerance_m, gross_payload_kg, evidence):
with self._lock:
self._assert_mutable()
i = self._required(instance_id)
port = self._port(position_m, tolerance_m, evidence)
if not _pf400_text(container_id) or container_id in i['containers'] or not _pf400_text(source_port_id) or (gross_payload_kg is not None and (not _pf400_number(gross_payload_kg) or gross_payload_kg < 0)):
raise ValueError('Unique container/source port and known nonnegative or explicitly unknown gross payload required')
i['containers'][container_id] = {**port, 'port_id': source_port_id, 'gross_payload_kg': gross_payload_kg, 'position_confirmed': True}
i['state']['sample.container_ids'].append(container_id)
i['state']['truth.registered_payloads'].append({'container_id': container_id, 'gross_payload_kg': gross_payload_kg})
i['revision'] += 1
def host_register_receiver_port(self, instance_id, port_id, *, position_m, tolerance_m, evidence):
with self._lock:
self._assert_mutable()
i = self._required(instance_id)
port = self._port(position_m, tolerance_m, evidence)
if not _pf400_text(port_id) or port_id in i['receivers']:
raise ValueError('Unique receiver port required')
i['receivers'][port_id] = port
i['state']['sample.receiver_port_ids'].append(port_id)
i['revision'] += 1
def host_register_constraint(self, instance_id, constraint_id, *, container_id, adapter, evidence):
with self._lock:
self._assert_mutable()
i = self._required(instance_id)
if not _pf400_text(constraint_id) or constraint_id in i['constraints'] or not isinstance(container_id, str) or container_id not in i['containers'] or not callable(adapter) or not _pf400_text(evidence):
raise ValueError('Unique constraint ID, registered container, callable host adapter and evidence required')
i['constraints'][constraint_id] = {'container_id': container_id, 'adapter': adapter, 'evidence': evidence}
def host_reconcile_fault(self, instance_id, *, attached_container_id, constraint_id, evidence, container_locations=None):
with self._lock:
self._assert_mutable()
i = self._required(instance_id)
if i['state']['motion.status'] != 'fault' or not _pf400_text(evidence):
raise ValueError('Faulted instance and explicit external reconciliation evidence required')
if attached_container_id is None:
if constraint_id is not None:
raise ValueError('Unattached state requires null constraint')
elif not isinstance(constraint_id, str) or constraint_id not in i['constraints'] or i['constraints'][constraint_id]['container_id'] != attached_container_id:
raise ValueError('Reconciled attachment must reference the registered matching constraint')
if container_locations is None:
container_locations = []
if not isinstance(container_locations, list):
raise ValueError('Explicit container location records must be a list')
updates = {}
for item in container_locations:
if not isinstance(item, dict) or set(item) != {'container_id', 'port_id', 'position_m', 'tolerance_m'} or not isinstance(item['container_id'], str) or item['container_id'] not in i['containers'] or item['container_id'] in updates or not _pf400_text(item['port_id']):
raise ValueError('Unique registered containers with explicit port and location required')
updates[item['container_id']] = {**self._port(item['position_m'], item['tolerance_m'], evidence), 'port_id': item['port_id'], 'position_confirmed': True}
for cid, update in updates.items():
i['containers'][cid].update(update)
i['state'].update({'sample.attached_container_id': attached_container_id, 'sample.constraint_id': constraint_id, 'motion.status': 'uninitialized', 'motion.target_joints': None, 'scene.joints': None, 'scene.tcp_position_m': None, 'scene.tool_yaw_rad': None, 'scene.end_effector_aabb_m': None, 'scene.sample_time_s': None})
i['evidence']['last_reconciliation'] = evidence
i['revision'] += 1
def debug_snapshot(self):
with self._lock:
return {'time_s': self.time_s, 'instances': {iid: _pf400_copy.deepcopy({'state': i['state'], 'revision': i['revision'], 'containers': i['containers'], 'receivers': i['receivers'], 'constraints': {cid: {k: v for k, v in c.items() if k != 'adapter'} for cid, c in i['constraints'].items()}, 'evidence': i['evidence']}) for iid, i in self._instances.items()}}
class PreciseFlex400Session:
def __init__(self, host, principal_id):
self.__host, self.__principal = host, principal_id
def _get(self, iid):
return self.__host._get(iid, self.__principal)
def _visible(self, sid):
slots = _pf400_slots()
return isinstance(sid, str) and sid in slots and (slots[sid]['visibility'] == 'agent' or self.__host._principals[self.__principal][0] in ('debug', 'evaluator'))
def _response(self, iid, rid=None, status='succeeded', result=None, observations=None, code=None, side='none'):
i = self._get(iid)
return {'protocol_version': '1.0.0', 'instance_id': iid if isinstance(iid, str) else None, 'request_id': rid if isinstance(rid, str) else None, 'operation_id': None, 'status': status, 'state_revision': i['revision'] if i else None,
'clock': {'domain': 'simulation', 'time_s': self.__host.time_s}, 'result': _pf400_copy.deepcopy(result or {}), 'observations': _pf400_copy.deepcopy(observations or {}),
'error': None if code is None else {'code': code, 'message': 'Request does not satisfy declared access, input or operating conditions.', 'retryable': False, 'side_effects': side, 'progress': None}}
def _error(self, iid, code, rid=None, status='rejected', side='none'):
return self._response(iid, rid, status, code=code, side=side)
def describe(self, *, asset_type_id=None, instance_id=None):
with self.__host._lock:
if (asset_type_id is None) == (instance_id is None) or (asset_type_id is not None and asset_type_id != PRECISEFLEX400_TYPE):
return self._error(instance_id, 'INVALID_ARGUMENT')
if instance_id is not None and self._get(instance_id) is None:
return self._error(instance_id, 'UNKNOWN_INSTANCE')
if self.__host._principals[self.__principal][1] == frozenset():
return self._error(instance_id, 'ACCESS_DENIED')
data = export_preciseflex400_contract_metadata()
data.pop('host_api')
data['state_slots'] = {sid: s for sid, s in data['state_slots'].items() if self._visible(sid)}
data.update({'protocol_version': '1.0.0', 'instance_id': instance_id, 'adapter': 'basic40_runtime_automation.PreciseFlex400Session'})
return data
def read(self, *, instance_id, state_ids=None):
with self.__host._lock:
i = self._get(instance_id)
if i is None:
return self._error(instance_id, 'UNKNOWN_INSTANCE')
if state_ids is None:
state_ids = [sid for sid in _pf400_slots() if self._visible(sid)]
if not isinstance(state_ids, list) or any(not isinstance(s, str) for s in state_ids) or len(set(state_ids)) != len(state_ids):
return self._error(instance_id, 'INVALID_ARGUMENT')
if any(not self._visible(sid) for sid in state_ids):
return self._error(instance_id, 'ACCESS_DENIED')
obs = {}
for sid in state_ids:
value = i['state'][sid]
pose_slot = sid.startswith('scene.')
stamp = i['state']['scene.sample_time_s'] if pose_slot else self.__host.time_s
obs[sid] = {'value': _pf400_copy.deepcopy(value), 'unit': _pf400_slots()[sid]['unit'], 'quality': 'unavailable' if value is None else 'stale' if pose_slot and stamp != self.__host.time_s else 'estimated' if pose_slot else 'valid', 'sample_time_s': stamp, 'sample_window_s': None}
if value is None:
obs[sid]['reason'] = 'No host-confirmed scene, setpoint or attachment is available.'
return self._response(instance_id, observations=obs)
def invoke(self, *, instance_id, capability_id, arguments, request_id):
with self.__host._lock:
i = self._get(instance_id)
if i is None:
return self._error(instance_id, 'UNKNOWN_INSTANCE', request_id)
if self.__host._callback_active:
return self._error(instance_id, 'BUSY', request_id)
if not isinstance(capability_id, str) or not isinstance(arguments, dict) or not _pf400_text(request_id) or len(request_id) > 256:
return self._error(instance_id, 'INVALID_ARGUMENT', request_id)
try:
digest = _pf400_json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False, separators=(',', ':'))
except (TypeError, ValueError, OverflowError, RecursionError):
return self._error(instance_id, 'INVALID_ARGUMENT', request_id)
key = (self.__principal, instance_id, request_id)
if key in self.__host._requests:
old, response = self.__host._requests[key]
return _pf400_copy.deepcopy(response) if old == digest else self._error(instance_id, 'REQUEST_CONFLICT', request_id)
response = self._execute(instance_id, i, capability_id, arguments, request_id)
self.__host._requests[key] = (digest, _pf400_copy.deepcopy(response))
return response
@staticmethod
def _near(position, port):
return _pf400_math.dist(tuple(position[k] for k in ('x_m', 'y_m', 'z_m')), tuple(port['position_m'][k] for k in ('x_m', 'y_m', 'z_m'))) <= port['tolerance_m']
def _execute(self, iid, i, cid, args, rid):
caps = export_preciseflex400_contract_metadata()['capabilities']
if cid not in caps:
return self._error(iid, 'UNKNOWN_CAPABILITY', rid)
cap, s = caps[cid], i['state']
if not _pf400_matches(args, cap['input_schema']):
return self._error(iid, 'INVALID_ARGUMENT', rid)
if cap['availability'] == 'unsupported':
return self._error(iid, 'UNSUPPORTED', rid, 'unsupported')
if cid == 'motion.forward_kinematics':
return self._response(iid, rid, result=preciseflex400_forward_kinematics(args['joints']))
if cid == 'state.read':
return self._response(iid, rid, result={sid: s[sid] for sid in cap['observes']})
if cid == 'power.set':
s['power.enabled'] = args['enabled']
elif cid == 'motion.set_joints':
if not s['power.enabled'] or not s['host.scene_bound'] or s['scene.joints'] is None or s['motion.status'] == 'fault':
return self._error(iid, 'PRECONDITION_FAILED', rid)
s['motion.target_joints'] = {k: float(v) for k, v in args['joints'].items()}
s['motion.status'] = 'target_pending'
else:
if not s['power.enabled'] or s['motion.status'] != 'ready' or s['scene.sample_time_s'] != self.__host.time_s:
return self._error(iid, 'PRECONDITION_FAILED', rid)
attach = cid == 'sample.attach'
if attach:
container = i['containers'].get(args['container_id'])
constraint = i['constraints'].get(args['constraint_id'])
if s['sample.attached_container_id'] is not None or container is None or not container['position_confirmed'] or constraint is None or constraint['container_id'] != args['container_id'] or container['gross_payload_kg'] is None or container['gross_payload_kg'] > .5 or not self._near(s['scene.tcp_position_m'], container):
return self._error(iid, 'PRECONDITION_FAILED', rid)
container_id, constraint_id, port_id = args['container_id'], args['constraint_id'], container['port_id']
else:
container_id, constraint_id = s['sample.attached_container_id'], s['sample.constraint_id']
port = i['receivers'].get(args['receiver_port_id'])
if container_id is None or constraint_id not in i['constraints'] or port is None or not self._near(s['scene.tcp_position_m'], port):
return self._error(iid, 'PRECONDITION_FAILED', rid)
constraint = i['constraints'][constraint_id]
port_id = args['receiver_port_id']
event = {'event': 'attach' if attach else 'release', 'container_id': container_id, 'constraint_id': constraint_id, 'port_id': port_id, 'time_s': self.__host.time_s, 'constraint_authority': 'host', 'robot': 'absent'}
self.__host._callback_active = True
try:
confirmed = constraint['adapter'](iid, _pf400_copy.deepcopy(event)) is True
except Exception:
confirmed = False
finally:
self.__host._callback_active = False
if not confirmed:
s['motion.status'] = 'fault'
i['containers'][container_id]['position_confirmed'] = False
i['revision'] += 1
return self._error(iid, 'DEVICE_ERROR', rid, 'failed', 'unknown')
s['sample.attached_container_id'] = container_id if attach else None
s['sample.constraint_id'] = constraint_id if attach else None
s['sample.events'].append(event)
if not attach:
i['containers'][container_id].update({'position_m': _pf400_copy.deepcopy(port['position_m']), 'tolerance_m': port['tolerance_m'], 'port_id': port_id, 'position_confirmed': True})
i['revision'] += 1
return self._response(iid, rid, result={sid: s[sid] for sid in cap['observes']})
def write(self, *, instance_id, state_id, value, request_id):
with self.__host._lock:
if self._get(instance_id) is None:
return self._error(instance_id, 'UNKNOWN_INSTANCE', request_id)
slots = _pf400_slots()
if not self._visible(state_id) or slots[state_id]['write_via'] is None:
return self._error(instance_id, 'ACCESS_DENIED', request_id)
via = slots[state_id]['write_via']
return self.invoke(instance_id=instance_id, capability_id=via['capability_id'], arguments={via['parameter']: value}, request_id=request_id)
# END CHEM-178 PRECISEFLEX 400 APPEND-ONLY RUNTIME
|