diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..f1a2e79 --- /dev/null +++ b/.gitignore @@ -0,0 +1,28 @@ +# Python +__pycache__/ +*.py[cod] +*$py.class +*.so +.Python +env/ +venv/ +*.egg-info/ +dist/ +build/ + +# IDE +.vscode/ +.idea/ +*.swp +*.swo +*~ + +# OS +.DS_Store +Thumbs.db + +# Device settings written during host runs +settings.json + +# Uploaded patterns (seed patterns live under src/patterns/) +/patterns/ diff --git a/Pipfile b/Pipfile new file mode 100644 index 0000000..2fd2ed1 --- /dev/null +++ b/Pipfile @@ -0,0 +1,21 @@ +[[source]] +url = "https://pypi.org/simple" +verify_ssl = true +name = "pypi" + +[packages] +mpremote = "*" +pyserial = "*" +esptool = "*" +watchfiles = "*" + +[dev-packages] + +[requires] +python_version = "3" + +[scripts] +dev = "sh -c 'PYTHONPATH=src:lib python -u src/main.py'" +device = 'watchfiles "./dev.py /dev/ttyACM0 src lib reset follow"' +test = "sh -c 'PYTHONPATH=src:lib python -u tests/artnet_dmx.py'" +install = "pipenv install" diff --git a/Pipfile.lock b/Pipfile.lock new file mode 100644 index 0000000..179c4df --- /dev/null +++ b/Pipfile.lock @@ -0,0 +1,746 @@ +{ + "_meta": { + "hash": { + "sha256": "618f924fcf42626185a65c0140b8d7a48fcf3e4fa5493a6a264541df6ea8cd5a" + }, + "pipfile-spec": 6, + "requires": { + "python_version": "3" + }, + "sources": [ + { + "name": "pypi", + "url": "https://pypi.org/simple", + "verify_ssl": true + } + ] + }, + "default": { + "anyio": { + "hashes": [ + "sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101", + "sha256:9f28306018cbd6d329e64a36d58256edff76dd996fe423bc957326e578b82a94" + ], + "markers": "python_version >= '3.10'", + "version": "==4.15.1" + }, + "bitarray": { + "hashes": [ + "sha256:00430df302dd0367e0aeae7dc71c0d250166e67514f828c853050560ebbaa782", + "sha256:027766e71da6063cb51fcd4c51f031ac14d5088ecb55e4500ffd692d78630dd3", + "sha256:04eb0d6c554e8769c492da71ef503fa955c1b078676b6a44d7e8d5e0808e53a8", + "sha256:051e0868e0b5ca53f2365b8840fe2ff54a68ae54ed2ff4e1e521db68c3d3f1df", + "sha256:0d868d83f34ee084ef18187e1ccfcff309550cf997a0c35ec2a13a4ec1d9b537", + "sha256:116a23f655f394f80f41fdc03368862485ac05534a56991eefb9f18f72e17f17", + "sha256:12249fecc687925e29a7879d8705a0af49305e5e3c7d5fe694586a2e6704ec0c", + "sha256:1382beba2a8c190c242f4251460c40348f5b1a7d125d93cd89f4e502fc6d4a72", + "sha256:155205159f3c38180a705253341b8200414c0198e86a9b9e2db49010236ff785", + "sha256:18e93f9822deca48eaa584b2bd3b165bb6e217f7e9b9538a3fb048ac1ae13ba2", + "sha256:1c49fc5f57eea2e859a3f2936a1fed84510af6f7464572b641485de2d22148cb", + "sha256:1de25e4714402ccb461a66ea5cee2229818b6cf6aaed420690dae32979ed7b3d", + "sha256:22befa4557bddcc4bbb9e565ae73635b6d7abdefc35a3fa784b9d534f86e6605", + "sha256:23ff70ee2f2a36ae089f769baeabe05753e02dd42b25aec20c78cd237af968ce", + "sha256:24122b069859bf99d50ae785f56deb0e97dd53d60bf2b47db5954d48cce84e97", + "sha256:260e31096fd8c833d3f39b6134fe9f87954f2482964e0aa377457d5649028906", + "sha256:301763ffde9d288c5a58dda51c5290bc1081c2bc0faf266c4aef227ca59004d5", + "sha256:30597fa6f4116eb6e374568d4f4de7e220462368ec7ce37d93403871bdf27a8c", + "sha256:31c06680231d37da8f4222c1d924d60f7c6809aa83797312b9697a127979fa7f", + "sha256:32e9fcd8fdeb1ca4e12a538a3e3a8ea50581bb1fcb3262cc67fe110bdb765580", + "sha256:36da946f64e10e28b23f345fde90f4d14e9c2e9013364fe04d9b2013e7291285", + "sha256:37f387c0cc9c63ab566551a819f2fbbc552a1d215f8d933ee285624eb3af6c83", + "sha256:386503399eec57cbfa73d63509315e557460ac20e2e12efb29c4163f171bdae6", + "sha256:387b64dc54be3732a0988bf3731fc06d7d4f52dc9470d1a5479e8ce2b67d368b", + "sha256:3889cf12ae0c04076772c8be66655bfe5925003b44dec056b569a68a121f7e93", + "sha256:3a1093eb1a756f08c7bdeb22969fb463aa62f036dc191ad371af5e292108c611", + "sha256:3d7a61fe396f14bc5435521ebbbcc7971ab4ae0b3523df5341d6dc9693f29f2d", + "sha256:3f87ce5c81d7f4a54b360731f8816c0106e9dc64ef4a2c4b9821840cf3e90791", + "sha256:403800cb9108b215b409c41b1c29be75c291813f40ba5db9099ca10294cc7648", + "sha256:41545b21384fd91767d294a5b3526c6306f7db577cf59ba72b51498e90bd52a7", + "sha256:470940879d8553fecddc3cf306b7d4b69fa0f5b7a6e3790b238fe553578061c1", + "sha256:4809eac58bcbef01915bc29e214f86ea70b52fab1a436af2c2f862709bd68b11", + "sha256:4b38439576ba0074ee454f1289396f51ffe1713b8a1077820be555bd5de0b737", + "sha256:4bddbc76e619a36d2abad14713c4dd970a8fa46a75a85ebbb626a2f26f1821d8", + "sha256:52741a1d24a3723a8151259906cf1befeaf3d4ccf7d3e27e8be4334590b59bcd", + "sha256:52b3101ea72ffe0433487dad46cc12b796c2c0546558682fc309a2828903afae", + "sha256:52e3cfb4fb883a81c80b14e9286030e9417627223d30e81e1397cd39f338aaf4", + "sha256:55370f00c52b5e46800fee0218a27a1b99db6e09113c1b804190c039e4350ea1", + "sha256:5605c8e74f95f77dd1b93c8c83d6fefe0d41d2704683d4a72152ca5284e2546d", + "sha256:56a2aa49e900aa927c147328e571da8a38a50ae99277ed093290845498dedefc", + "sha256:5db38c0a36d07190c3629c65dab2504233a56b1c35d8b1cc3d7369943d028711", + "sha256:5f2578852b9280291a1b3484930587be9604af6495feb218b86aeee995f4d6ff", + "sha256:664f02e6e2c63fcc1c02718d2daa21b04f77a18ef3850a9b348597c0c8a0f222", + "sha256:769d93669a90e33282eaccb33537a4a80b314e476ed16fc986e0148bcc72ceb3", + "sha256:7ad6b6cd9558529a9e51ef981cef5b3439acd0a913d25562dc56220078bd4968", + "sha256:7b16df7ddef03e30622d894cce86a560b7888415ddcac470eb99940a5adf1a35", + "sha256:7d1c46e15d426d88420877a8a56aeb70fa5487c53c42185937254bbc076d3af8", + "sha256:819341386eb8a031eba8471ca72723e1bcdc56e35e79f9faa04e265cf64368a3", + "sha256:823638d0a900cea53c173fb31f5f1f4b913065a92fa3406d9b20eb7b7ebf189d", + "sha256:86dfaab663a2ad16ed2f6252116cf034cfc84282aa744f19a9a66542e85c9ca9", + "sha256:8b77aa18131418b869be882df1c5e229fb02f90861783bbe638d9ebe296e9209", + "sha256:8d3763f5061d890c522ee7a16c42c7fedbd114d8a031f6121471504704a70253", + "sha256:8e799c9eaa4f10b14fa34430e5bd0d8668bbbe5c4eb0f59697ecde902304842f", + "sha256:903a9a62521fe84b4126ecfefbb2755ce50a6dbd8be96a021c5e8990883b234a", + "sha256:93a7f9f9f848ec79f19fdd39f3b8f750d9abf8e65cd6fb3a045df192de23855d", + "sha256:962dc3e5622a08bb1c1ad429a9f7dace7efadd7fef1fcdf1628a6db142333256", + "sha256:9767500d7c180eac5f6bb08819fcfa6630b609d52d51b3396a3c9f9809f78743", + "sha256:97cd5913000e4e56d211f7db053284d1f753aed34838368769bf084474a76f0a", + "sha256:9808734d1e5fd2839660a9db1abfe93e9d64b2aa9ed59aa480193ad93e8d620e", + "sha256:9aafe7dc6d568470f5c297d0b15acddd3afc1677c983f0460b28f8cac4e9360c", + "sha256:9ba6f68d39a160b9175ba3710e45ba560731805f10bfcd716184c9bfd3d60cf4", + "sha256:9db61968efb834dacda6bcd7ef1f8a033253a53ac31426a684a28a7e4c9f2f29", + "sha256:aac6b951d9f50280728a61e5edadb0d109930dff9b42c6ad45aad7a4f2df1503", + "sha256:ab0988829e4ed10fa971842e9fbf77595b8a4557a078a3589b0754f06417ddff", + "sha256:ac322a81c3c938c13093d8d77c419093f50118c29fbfa9eb80813d93af1a2d95", + "sha256:ae83b41711788b7c2b0ea2230176e1caf3349119c1dd62c8e35e62809e0f7893", + "sha256:afe8ee837c085eeeaead62429f260a2de3a0602d1a34bcdead8b9f0388ef6114", + "sha256:b0d57b41cd5d91d9ebe4cbf88c58455f235b119fa7c43cd3b87d79d161a4c731", + "sha256:b1f90eb79230a2d2407b7c08857634f0868c67fd5ab849eb812c75c496fa7e40", + "sha256:b1fb6d974e70eb5d4b5845fb890024154a85017f2101d11681c3836332cc0cbb", + "sha256:b22b4df5f5e76e4c9b033570ce13b750d8209e198bc8e1c7bf012a4688e42bee", + "sha256:b2e67fb3527d15b32b641dd2c3bd15eceb3407877d717e06ef98b60792606e1d", + "sha256:b313dec833e8ca77068d8bcc983d2ce09a97304dd715a80a4d7e50b5b030fd1e", + "sha256:b4afbb464a1db2d37858bd3b87bd59a76b4aae5e29ec007a9fd00bf5a911e1da", + "sha256:bca7decc355277a7bc4fb315e90d557341c1e0558488f6dcd2101fd410db6307", + "sha256:be64657bf842bea37790ef304f88a6465e566355a42c04f3767635b92b35beb2", + "sha256:bf19437ec00ec3d40aef82eaeedc14cf4000be9b635c4f5049796506e6630dd8", + "sha256:c1019995c19fdfbf53226d8c8af95523fbd9c74f5c375ccc0673ccf39eb14c31", + "sha256:c143d28bee6473186f8a76c18937ec84bdc3cd4cb8d5350766481143aa7706a3", + "sha256:c231217ef0ec0352d9327eaa61c0ab26252ad6b9a90002365f603470869a48d2", + "sha256:c4cabc2439ab3ce76881037741bf41e9fafda217ff721fdee92701e5fe3c8b9c", + "sha256:c54a7b5fa924f016d725b6056d9e4a97ab2ef6ad8c049e916c532d723187a5d5", + "sha256:c56b9a61235fae422c670835ac36eb70e20582d1956401b38fd25c3291af9378", + "sha256:c5bdd4531df12676d19bdfcce4d773c1f790448a7e1db3a2710fb674428987ef", + "sha256:cccc658d26c464409c46b9c41028a1c3c5da90bec6e7330c69a646f34199451a", + "sha256:cfbbb23d8db2abe2cd098157ea35e1e9860d1c26e2487422b5a39ef6eb85c549", + "sha256:d084fa59c94d3fec7eac6793e08162fa697aa4e70b9f519618c29d3e54eda752", + "sha256:d62e73fcdd273d07b1e9699de0e66e4d367b28c554c86bfe7c92029337c2a414", + "sha256:d66597cdffaffe106f057874c9e95e4f84c4ee701a271b6213325ebd423ce13b", + "sha256:db35aa7cc2f236d8bef09da1a67fe145e376b7ca5f95195dd6fc9dcd82cc4ce2", + "sha256:de25b8c76fe9fe7d9c6bce2832096f020133e1d21e2841abd7280937bf90e56e", + "sha256:e5efe99e2525d288eeeb5f71a026a2d5280702f73c835a2bac58f2932adf6af9", + "sha256:e9beee2047addf3e404eaeeb0da785b43fe91b942a0e5416dc821de5bb9349ef", + "sha256:ec3d8b99a92220bdba382acf4eff370d6a6cda34a5ce936726cb9e8cf2427c47", + "sha256:ece8caff2fb31d6c69430d3dfc0efff70083e66b012f7f5de60cfe5dca98ba87", + "sha256:ed14ff0c75ca56b6bcb51443f3dfb7743414159538c1bbaa3b73b8228372b096", + "sha256:f0df7eadda7086bf8ebf0a9bc7b5b8386ba5061d3f888f1f088ab8d877c33144", + "sha256:f23601f400323c7a8b57d271f6b841c40630afe24ddffd0c5be99ce3dec486e9", + "sha256:f5c5f9b79689a6826a4d4dd912506028538b672fc93533d0b2b6247406751e54", + "sha256:fb7ad4e6ee69cf53f12bdb7b306964dcdf8d58c20180c8d841eba029fc7b4847", + "sha256:fbd3da71fcc23143f901a2c7698f3a10017ec8f1d0f7740b6854e907f860cb04", + "sha256:fc08c36ac282866d44325aaa778892394087ce88a64475d48abe52b564da85b1", + "sha256:fcc8d9723956af19afb215ffb82a39ab810bc8bca2000640b3fd8c884307a6f3", + "sha256:ff7cd750397eb61cb43bd368a4e1f7ce8897ab3bd26e7e5b90a60ec339588df0" + ], + "markers": "python_version >= '3.7'", + "version": "==3.11.0" + }, + "bitstring": { + "hashes": [ + "sha256:e682ac522bb63e041d16cbc9d0ca86a4f00194db16d0847c7efe066f836b2e37", + "sha256:feac49524fcf3ef27e6081e86f02b10d2adf6c3773bf22fbe0e7eea9534bc737" + ], + "markers": "python_version >= '3.8'", + "version": "==4.4.0" + }, + "cffi": { + "hashes": [ + "sha256:046bfc24911b37851ee1b51aab8bffe713d89c68c6a057b09484ce9fd5f69b4e", + "sha256:06c72bb76605a4b0cd0aad6930b69d4baf7dd5d806cfc409b824191099700e66", + "sha256:0beceaabe56af686895136a2de78db54ecd8e4046b236b8fd6d6cb61389e9bf2", + "sha256:154852545011f779917b11c78db2358d095da62a9a172b78ad0a583ee5adc0d0", + "sha256:194cffa889098ced9976c3fc6340305e43f6303657d298da55366907c05c22d6", + "sha256:19ee6127ee34de7d83ce3d371ebc5ed91addbdcc39f9ab15ce4eb35a4e534971", + "sha256:1a18a57b58cfb21fc28d72e876acf10eaed67a1ed96226f92af4df681d571c4c", + "sha256:1aa5645c30469b09530c4ebca77ebf8f17618293c58f8549cb1a543a50236e7d", + "sha256:1dea0e4d7d4f11f619fe8c1d76caf49e24405b4b5743c0e3be16a500ecd930c9", + "sha256:208f941bb9d18e768138677f0a6d2ce01f590df56043dda1df1535ac57c88517", + "sha256:210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735", + "sha256:246fa40ce8645a614ff682e0b70f37134e460eaf93a775e0cbe3cca585a67a80", + "sha256:25792eac27877609e7bb06d42ff88278a6624fff2ba9bbb523c09616b117e80f", + "sha256:27350daa11d4f10c540e6e89dada4c54feb7256ad03e9a4dc075ebad7ba360d1", + "sha256:28907ab9bfb6aa13184cfc17c6b8e1023c5ab6fd7076d8c20a35e59fe04f8f29", + "sha256:2ae64be792b8966f2c69538199728b290e34726562896df1e5dc8ffd8d8188e8", + "sha256:31348097ff5bbe827ccc41795d4dd099d9f0625e7def00ee653c137a490c2a6c", + "sha256:3143d81e29e1e20a9ce10901ec369012947876596f75a222235965f2b7ae832e", + "sha256:3222ba5d678f80a030e6afbcc33dc1ae5cb45facabb61cee2c7016b8432fde48", + "sha256:3311ed60d36f83378794e1009ac6258bafbf81f7888b4caa7b35a521e3f95813", + "sha256:334644fbac4eff73d985a17a91226df55d0f394160c4cfb880e084c8f7161cac", + "sha256:34e261f78cb6ceaaa36f42f2613f4380d94d9c759a9c73c769ee6e0247364632", + "sha256:363e05fa78e15116c3c32c210ee36884fd6b9afa6d440e47112c3bd511d64cb6", + "sha256:398aff33cee2767e3e781d2554c54bd0dff386bb437581e0d8011fde1a942ec1", + "sha256:3d22a20b1fb1632cc72c22f95f7b0d2961c3e1c235f245ba4c606c4771035659", + "sha256:42a494cee34437f05546455144f2b5d9ac09b1face62bcfce597d2e521066688", + "sha256:42e2f76b9455f5a9a844f770bf3e200ed3da0e15f5df3db9c31fe80b04b3d004", + "sha256:42f6930c31dc7f50732c9ae793c2786c7b6b044195967bbdde40bb9be81c4cc0", + "sha256:456a61fa52d579ebf9df2e9552ead5129855dbaff6c1e5a9b1bc408809bdc062", + "sha256:471cee653ae88de62096552e6d24ccb4a5adb8c8c9f10b5054d0122c15bf2779", + "sha256:49cbc70e6542d4ccccb936558d1064a8012541e78f821f955cff24e357776c94", + "sha256:4a7c934f7360e8cd64fe9efadcbd10c7c6364f531e432b9a4bf5ccbc9e0e8b50", + "sha256:4be96343e422f2dfcd12ab5c9f5aebe03f82f737c6bffeca6830b3875cb44aab", + "sha256:4f42141fc14250de6dde5ee7ea4432be017252d91f19c5ad043c084cea629cac", + "sha256:507a24c282e0f42f8ed737cf048572cbf580468da5555764a8331735e9c736b6", + "sha256:51b31d1c98274844cfd7838ce00bfc27c7423a4dc00fc0772fc3331c2cc90676", + "sha256:58acb8ab8e295e6c5ea12f888cbb13cf21511ef2a3303a23f4325c29d17fe5c1", + "sha256:5a59cc1c4442bc3d5c703bf720b51138d0bfc173618807c9ee2490a7541dd3d9", + "sha256:5bb4e7ea95dcd6a014a6fef62e62467d67d8e582326443f3d68e71d6320a9fcf", + "sha256:5c58fe613dc5e5336357eff555824a314d8e43282600435c8d1cb6a7a2fedd13", + "sha256:5e7cecbaadb83884793e05828cee59b210b24583b9c7425d0ba6a754fe22eb4e", + "sha256:616f097f2fe415bc92a247f02e11f634e1f9e9a83d327e3c915c15089c87869e", + "sha256:63bbfd5ded17c4840ac07cd8f1c21ba9d9708141f840b324f422f41b207e3973", + "sha256:64faea20f4e2613363a1a9b9c7dd73058f3ecd00133a511e72ad7c511658f527", + "sha256:661c298b4821edebead0c91edd2b00374d67ad7c5a1f7a91d4442633b79d6a72", + "sha256:68e62fe11f30d5ca8289242866f0a5291402d8529ca2178ab8afc5c9694ae890", + "sha256:6a8dddef476fab96d066d578fc88526767b836ab5ab21754e1d5bf3879c31c7c", + "sha256:6e192623c49c94421616a5778fba35cf0d5a8d000650c1967ef4448ee5cdd990", + "sha256:7225e4514edb64eb6740324353e0da0711954fd8d7da4576755b1c6e09b697cd", + "sha256:75f80557d1389eddbd0de2681f6a390a0c5338c31ddaa821381c203fc3fd50d9", + "sha256:770de9db11e84213beec501cfcaa013b019820ca881e03344dea5844f7876d94", + "sha256:7750c6449dff7864bb9bb27ddfb0267756189201a3afc911d82b3caacd70dfc3", + "sha256:7bde5e4cc5c10140859842b9d383af292b22639a4dffb725314baf45968cef80", + "sha256:7ce713ace7c0e4520535b42b77eaa742c16dab813978064913e5a3cf82973b41", + "sha256:7da0c5eff80f0197f3b3d1232ec5a682a9325f4ae9016a78f5f5ca35f9ced1f5", + "sha256:7dbb61fe3a7699468030f71bbe5f8a0e326a151daa91beb11a6fc1f980c55e1c", + "sha256:811bd1e21d32de12efca32393a0ab3f5133b54fce9bd44b8bd77ab07da14bf6a", + "sha256:8ef53b2de9bcb9197d31854256575d59dbac0cba72ac627bb291ef5eceb74be4", + "sha256:937c0052c05a31ca1daf18de3158eed4dbfcb9cc107adbea227728d647be701e", + "sha256:9d2055050ea716bd38b7f7f1579c275386646b4894c155a3e2f3cd62ed41b7c6", + "sha256:9f8d177621de5cb38ee3e731eda45d421db093ec0739f46a5594babda7987a98", + "sha256:a2d7755bef5a12ed488f4ef1f1b69ee9191d7396083b755a5d2295f6edb4768b", + "sha256:a48d62ab9d6f4f98c983223a547af44be6ca3691074c31cecced6facd3ba2dc1", + "sha256:a4f00aa42f75d6e4595e8866e748cc1705adc0cddfeb2ca86d0d03993d63ba03", + "sha256:a6e721d4b0e45d5b65e87534470e67b18dcd092c83f68fba09f152b9cbc061af", + "sha256:a730a083190634c65cca36ba5f489531576ebd79bcd5c8e172130f6453127231", + "sha256:a931079504ecc49efed7744c476a5c343a92fabf66dec2db95edb1b2fdc770e2", + "sha256:aa9511c62d14da7aacc9b4bf51f3f697a621e83b2d6919008243c3aad168eea3", + "sha256:ab36d55f9ed2d067327667c2fea18dda018eb628dd6347aa01dda6cf1f5d3836", + "sha256:ad2c86c495b899d862ea0f4b42891b8713a3bd45dd4105c7fd51c2a72f39f3a5", + "sha256:aeae0e330c9f6acd681f647d46cefd30c29f93e3392882e792e82080c9691399", + "sha256:b0431303acaea1089ad4b3e9ce4e6518193def1118d4073ca848635ee4ea2e96", + "sha256:b5bdfd1c873d4e093aabc0ca84c4ca6dbc4f752afb5c86f146d9742580c9da2e", + "sha256:baed1e86cc735622097354b9d1281406caf42ff42a886d29faa8e8d1630333be", + "sha256:c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf", + "sha256:c26608d2222fb1e94487e4a387d85f13eb55d5ed725cb25a0c589ac4ee60e7bc", + "sha256:c7659f22557c5a0bc4855cd635f55edec690cc008a40768527762cb9fb263455", + "sha256:c8c69575568085ba0b1b10c0249d779a214aea6f6522e949a0fc9fb0fcb449d0", + "sha256:c8d2c9fd1f2d16f780d15127abb050d13d1a76c03a4bd87d7e4980e45e511e12", + "sha256:ca82be1a1d406ecfe1d25dc16cb33488e5a16bf4438c9fb590484ea29d92478b", + "sha256:cc572dace3f60ef98d7b12ff411d20f5362feb31a0439eab0085bbfd349982d7", + "sha256:d18e5ac0f2f03f4f518d3e23db0f0cad7faa1da8620e9c09461d443bbf6e6692", + "sha256:d28630f5854ab07ab1fd4aba756de52326c82e6be15d414b12793f1975048b54", + "sha256:d9c275eaacd24aa73f94ffd6de08fc3f932424d8b6c376f4bed7cde376fe7bc3", + "sha256:da0e573f9f97159390c89d9f1a9e41908b66d408cc5b58d08cf3847d844c531b", + "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", + "sha256:dddad92b554513a31f272570678ba307fb9f618f05e3d4a5eacafff9eae03e1d", + "sha256:df423d40ee8654634421812bc3b196da3f9bd7d32929da813f8394c4348a5358", + "sha256:df913725b79db7bcf03448f36b7bf8815363417d5b58deecf9305e3e30f0f21a", + "sha256:e0bcb7e0f677f543555d2adff3bf19c05f66cdb4796e5ff602442ab2fe3c4ef7", + "sha256:e2d65b31f36619cda3999b78b2aa9632e76b78448e7a56fc4240824200e7c4fc", + "sha256:e6e8cff14d6fb0be70a09c0bdc58096f501952d04624ebf867e0e56da2df8960", + "sha256:f16c709686a78c727bbbf059f92b0bf41c6fc60deec706d2dc19f529175a6125", + "sha256:f24fb43132a4c6b4cb4eb029492919b2db645be6808d738f244fd146c03c32cb", + "sha256:f53e442b08449d42821fa4a4fba000095af9f62742a500f978a9f557ec44339a", + "sha256:f5cfbc5fe74540d335175b656c725d74d90e3730c626d92575eea35029d9afaa", + "sha256:f81b3b8f3d4e343550fa4baa0e479bba9f2d29ce9c2e9b51d1ce1718d7442fcf", + "sha256:f8ec5e643a9a937f64e1999eb9f75d072263751912dc5cd06d3c85f8f44be7c3", + "sha256:fb92203a88b3d3053034db775110081c49d28be6551923805e039924093761e4", + "sha256:fcd22650c908d7b7da162bbfaab594a1227a15d1643a98c68b122ac642fa2264" + ], + "markers": "platform_python_implementation != 'PyPy'", + "version": "==2.1.1" + }, + "click": { + "hashes": [ + "sha256:255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360", + "sha256:ba0d2089de75ea0310e2dde03160e6ca10009947fb95a182f9b54021bb272e34" + ], + "markers": "python_version >= '3.10'", + "version": "==8.5.0" + }, + "cryptography": { + "hashes": [ + "sha256:01f41478cf33fc605a6a089cd56d28b45c6c0b45a1928b61797f2621a04bac71", + "sha256:05ba322c4da95b262a212c345af888ef2c37c88c0509756ea00a0e6d68850f23", + "sha256:16c5ecd954b3330ebfb6605eca4fd952da8bef376551d5cc264534e3770a9ee6", + "sha256:2a93d05e34d5f67fba6f891fe85d929999baa7195e853923ea6d7576c9e68c5e", + "sha256:2b34d76a652ea2b6faf777c35df230c5637842cd904e04f16230c3f9f03e4361", + "sha256:2ebbfb0f1fed745e91796e3e1080a1440423fdae8ece1b995a1d80883a409054", + "sha256:30a125032e5642a21ff816e021152bd4e7e94f03eff3f4b7fca41cd22bc3110f", + "sha256:330fbb252391c596f1ae42c5754449dc924e6ad012dca8efe0d703f9f2d12ec6", + "sha256:359e62deae718bce96170e223fdcb6357e4fbd3bb7a3a75f4430763532560e49", + "sha256:407fe2b6db00939c05c0e945e9914238f2f0a430974839429dafc82b1ee6bee5", + "sha256:42be3bb70596b3abe4ac097b75be223e8b3ab614a0e5de068e3dcc54d71d6149", + "sha256:4c4188f7c0cf655be5c06342b817ed0f9595b69ffa2b12026e5353eed29dea88", + "sha256:51593d180cf6d179bde5c5d065bed81386b1f381656ae7d042b7ffc87a9895ad", + "sha256:51afcfceb15597cf2635068e4ac9a56b2abde622edde17f37d85fd7b5306497a", + "sha256:53e279950892dc102c6b4e52af03ae5ea92fac572a1ddab78ca73a997f62b69f", + "sha256:55d16b1ef3ee0958d893a977b19777887e546c9954ea81b200c3301a864013f2", + "sha256:5dd9bda1c12b4162f6ff568eeb5e0ff956c28d14406e875cfe8a63a2d414ff20", + "sha256:5fe002589592ed749ce77fe0695fcbd3500dd61d7d6db5858a7544c612fa8e45", + "sha256:5fe939deeb161024a6be98229c953b6591fef1f41214497a78fe793a244c017f", + "sha256:693c99b49bd37d0d096e4334c10232c77248c415b98d35236094cdf96d57258b", + "sha256:76de83fbd91ac49c0feaaa983d0748fd7a53176afac5fb3bf7478d244f0eb527", + "sha256:79bf008d1f9af6071c797ad133e39915dfee7614f18f18f4db9072eb715064a3", + "sha256:804728ce710890870f3aaa344b2e161172d258d768ac139d02cfd9092d0d94e6", + "sha256:8921d58f426793c5f1b47f0b59575780de9a095214958d0eb37d909593db8367", + "sha256:8df2de9102026855887e4587084f6eabd80ed0f345b8ad8a7ac27ab9bf4723e0", + "sha256:9cb3cb952cf5a8abd50c782a98a89d71699715e802fe349704b47f2425b42a94", + "sha256:9dde0a357190eb3b1da1bb9ab750e9c85cba82ca5977aa0836cbb94e92611239", + "sha256:9ebcdd5519be9b652a46f507817a74591774fc3d6923ac364e4dfa64e36b291b", + "sha256:a0b1a59e3a089064a0ec309e9428c8e3ae4e161419d20ac33600767e83fc658a", + "sha256:a255449073358275b64b67d3f595f268bbef70e72b6edb65e0c70c735bf739c9", + "sha256:a8f40ea47330e71b594a7e246898f93177c259490c63183dbaf9e571d71ed9a5", + "sha256:ac02b07824d4d1001bd4367599f839c19cb171924c796e52c23508ac14c2c0cc", + "sha256:aed8db4f6d71c51efb89530e12d9464e7bf2923d46c3205dc794a2a93f8c0648", + "sha256:b8f852c65863251b9e3a1b8c150ce21e59b522dbb6a7d4bc80e680d38388e986", + "sha256:be224a65493ec5b74a158ff22a5522ce4a5ca1e543c647a3a4730d4a09e5f959", + "sha256:ca83d00d9e69cd5eb63f2e69c3a5a59e0cecae5ae14c6ae0b35830fe3b37bad0", + "sha256:cbf74a81765ee67413503ca6e26dcc4f6f5a519822436cc0a1b97aab6c1b8a17", + "sha256:d63ae8f6481fec907ac0f588eee8a90aefde112c633131fe540e5711ddbb5a4e", + "sha256:e22dfed744bd4002e909464cb23d2f0b05c6f3113a79ef2e9864a53db737c733", + "sha256:e2ca8fd1b6b4b82a1c4cb02841d0837e3c12336c2e24b520ab8ab3b969733d8f", + "sha256:e74591e283fe6eb956416c929eb58262a719fe0311fd9054c62c3350ed8760d8", + "sha256:f74455bb086a85d5e81246412602aaa97ed095e504cd40dd261ef50be42205bf", + "sha256:fb4b9672d389c738b175c4166e78310f8a70358886aacd9173ee03a85ffdc671", + "sha256:fc3ed7ebd2a8c96f5b166de0ab9b624996bef3b07bbeb19364dfb78222c22c80", + "sha256:fd3718b960d0b5dd213cdf03f3bcb7000e69dda0de8b956061947ff6bcff5558", + "sha256:ff838d62ec1bfce4f9ba7fa16f4a7b554cd8d0c299e6be37502161a660c84eef" + ], + "markers": "python_version >= '3.9' and python_full_version not in '3.9.0, 3.9.1'", + "version": "==50.0.1" + }, + "esp-pylib": { + "extras": [ + "cli", + "ide", + "serial" + ], + "hashes": [ + "sha256:3006bc9562f9526957e09ee848817463c22fe10ccf8ea68b61553906cbc089e0", + "sha256:be04824c2da8d0af3ae891f93d0e4059c14d5f2c3c828b19a1c12d916c6a4d74" + ], + "markers": "python_version >= '3.7'", + "version": "==1.1.5" + }, + "esptool": { + "hashes": [ + "sha256:fd756598db0a26c9975fa18511b08687c54bf2ce7322ede80cf1f5117dad1f50" + ], + "index": "pypi", + "markers": "python_version >= '3.10'", + "version": "==5.4.0" + }, + "idna": { + "hashes": [ + "sha256:a7db850025b95ded1eae8a46181a1a6c56c92c96f0e2b005d9ff8dc0210cab44", + "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c" + ], + "markers": "python_version >= '3.9'", + "version": "==3.20" + }, + "intelhex": { + "hashes": [ + "sha256:87cc5225657524ec6361354be928adfd56bcf2a3dcc646c40f8f094c39c07db4", + "sha256:892b7361a719f4945237da8ccf754e9513db32f5628852785aea108dcd250093" + ], + "version": "==2.3.0" + }, + "markdown-it-py": { + "hashes": [ + "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", + "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a" + ], + "markers": "python_version >= '3.10'", + "version": "==4.2.0" + }, + "mdurl": { + "hashes": [ + "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", + "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba" + ], + "markers": "python_version >= '3.7'", + "version": "==0.1.2" + }, + "mpremote": { + "hashes": [ + "sha256:ab0b6f21059698e573ca076fe9a0299e5fe7bbc3ca3f5b2f00007e22e51c7b80", + "sha256:dedac688bcd65b9d4d5b7a66119332f2830000088321107994959333f53e41c8" + ], + "index": "pypi", + "markers": "python_version >= '3.4'", + "version": "==1.29.0" + }, + "platformdirs": { + "hashes": [ + "sha256:38da801a4af303033cbffccb39030db22bf0473e6414309b02acebeee7ca8bf1", + "sha256:7f251621befae78b2cb74616f9fc99d3fa3db0afba5035987731f8dcd430337d" + ], + "markers": "python_version >= '3.10'", + "version": "==4.12.1" + }, + "pycparser": { + "hashes": [ + "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", + "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992" + ], + "markers": "implementation_name != 'PyPy'", + "version": "==3.0" + }, + "pygments": { + "hashes": [ + "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", + "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c" + ], + "markers": "python_version >= '3.9'", + "version": "==2.21.0" + }, + "pyserial": { + "hashes": [ + "sha256:3c77e014170dfffbd816e6ffc205e9842efb10be9f58ec16d3e8675b4925cddb", + "sha256:c4451db6ba391ca6ca299fb3ec7bae67a5c55dde170964c7a14ceefec02f2cf0" + ], + "index": "pypi", + "version": "==3.5" + }, + "pyyaml": { + "hashes": [ + "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", + "sha256:0150219816b6a1fa26fb4699fb7daa9caf09eb1999f3b70fb6e786805e80375a", + "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", + "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", + "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", + "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", + "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", + "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", + "sha256:1ebe39cb5fc479422b83de611d14e2c0d3bb2a18bbcb01f229ab3cfbd8fee7a0", + "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", + "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", + "sha256:22ba7cfcad58ef3ecddc7ed1db3409af68d023b7f940da23c6c2a1890976eda6", + "sha256:27c0abcb4a5dac13684a37f76e701e054692a9b2d3064b70f5e4eb54810553d7", + "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", + "sha256:2e71d11abed7344e42a8849600193d15b6def118602c4c176f748e4583246007", + "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", + "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", + "sha256:3c5677e12444c15717b902a5798264fa7909e41153cdf9ef7ad571b704a63dd9", + "sha256:3ff07ec89bae51176c0549bc4c63aa6202991da2d9a6129d7aef7f1407d3f295", + "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", + "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", + "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", + "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", + "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", + "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", + "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", + "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", + "sha256:5cf4e27da7e3fbed4d6c3d8e797387aaad68102272f8f9752883bc32d61cb87b", + "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", + "sha256:5ed875a24292240029e4483f9d4a4b8a1ae08843b9c54f43fcc11e404532a8a5", + "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", + "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", + "sha256:6344df0d5755a2c9a276d4473ae6b90647e216ab4757f8426893b5dd2ac3f369", + "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", + "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", + "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", + "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", + "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", + "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", + "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", + "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", + "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", + "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", + "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", + "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", + "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", + "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", + "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", + "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", + "sha256:9c57bb8c96f6d1808c030b1687b9b5fb476abaa47f0db9c0101f5e9f394e97f4", + "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", + "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", + "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", + "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", + "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", + "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", + "sha256:b865addae83924361678b652338317d1bd7e79b1f4596f96b96c77a5a34b34da", + "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", + "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", + "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", + "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", + "sha256:c2514fceb77bc5e7a2f7adfaa1feb2fb311607c9cb518dbc378688ec73d8292f", + "sha256:c3355370a2c156cffb25e876646f149d5d68f5e0a3ce86a5084dd0b64a994917", + "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", + "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", + "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", + "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", + "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", + "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", + "sha256:efd7b85f94a6f21e4932043973a7ba2613b059c4a000551892ac9f1d11f5baf3", + "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", + "sha256:fa160448684b4e94d80416c0fa4aac48967a969efe22931448d853ada8baf926", + "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0" + ], + "markers": "python_version >= '3.8'", + "version": "==6.0.3" + }, + "reedsolo": { + "hashes": [ + "sha256:2b6a3e402a1ee3e1eea3f932f81e6c0b7bbc615588074dca1dbbcdeb055002bd", + "sha256:c1359f02742751afe0f1c0de9f0772cc113835aa2855d2db420ea24393c87732" + ], + "version": "==1.7.0" + }, + "rich": { + "hashes": [ + "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", + "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36" + ], + "markers": "python_full_version >= '3.9.0'", + "version": "==15.0.0" + }, + "rich-click": { + "hashes": [ + "sha256:324cba7513cd4187ee92b2eef21f071714e45be062458c8b157bd7e0c81103e3", + "sha256:365e7a9d0adb42e41ea832a0a12e02c44c079a26536dee688125eb9814f97274" + ], + "markers": "python_version >= '3.8'", + "version": "==1.9.9" + }, + "tibs": { + "hashes": [ + "sha256:01ea5258bdf942d21560dc07d532082cd04f07cfef65fedd58ae84f7d0d2562a", + "sha256:0a7ce857ef05c59dc61abadc31c4b9b1e3c62f9e5fb29217988c308936aea71e", + "sha256:130bc68ff500fc8185677df7a97350b5d5339e6ba7e325bc3031337f6424ede7", + "sha256:173dfbecb2309edd9771f453580c88cf251e775613461566b23dbd756b3d54cb", + "sha256:1906729038b85c3b4c040aa28a456d85bc976d0c5007177350eb73374ffa0fd0", + "sha256:1b56583db148e5094d781c3d746815dbcbb6378c6f813c8ce291efd4ab21da8b", + "sha256:1d5521cc6768bfa6282a0c591ba06b079ab91b5c7d5696925ad2abac59779a54", + "sha256:1f95d5db62960205a1e9eba73ce67dc14e7366ae080cd4e5b6f005ebd90faf02", + "sha256:29480bf03e3372a5f9cc59ea0541f76f8efd696d4f0d214715e94247c342a037", + "sha256:2a618de62004d9217d2d2ab0f7f9bbdd098c12642dc01f07b3fb00f0b5f3131a", + "sha256:42725200f1b02687ed6e6a1c01e0ec150dc829d21d901ffc74cc0ac4d821f57f", + "sha256:477608f9b87e24a22ab6d50b81da04a5cb59bfa49598ff7ec5165035a18fb392", + "sha256:4b7510235379368b7523f624d46e0680f3706e3a3965877a6583cdcb598b8bac", + "sha256:501728d096e10d9a165aa526743d47418a6bbfd7b084fa47ecb22be7641d3edb", + "sha256:63255749f937c5e6fedcc7d54e7bd359aef711017e6855f373b0510a14ee2215", + "sha256:6a9feed5931b881809a950eca0e01e757113e2383a2af06a3e6982f110c869e2", + "sha256:76746f01b3db9dbd802f5e615f11f68df7a29ecef521b082dca53f3fa7d0084f", + "sha256:77103a9f1af72ac4cf5006828d0fb21578d19ce55fd990e9a1c8e46fd549561f", + "sha256:7d6592ed93c6748acd39df484c1ee24d40ee247c2a20ca38ba03363506fd24f3", + "sha256:847709c108800ad6a45efaf9a040628278956938a4897f7427a2587013dc3b98", + "sha256:859f05315ffb307d3474c505d694f3a547f00730a024c982f5f60316a5505b3c", + "sha256:a61d36155f8ab8642e1b6744e13822f72050fc7ec4f86ec6965295afa04949e2", + "sha256:a883ca13a922a66b2c1326a9c188123a574741a72510a4bf52fd6f97db191e44", + "sha256:ac0aa2aae38f7325c91c261ce1d18f769c4c7033c98d6ea3ea5534585cf16452", + "sha256:ace018a057459e3dccd06a4aae1c5c8cd57e352b263dcef534ae39bf3e03b5cf", + "sha256:ad61df93b50f875b277ab736c5d37b6bce56f9abce489a22f4e02d9daa2966e3", + "sha256:b9535dc7b7484904a58b51bd8e64da7efbf1d8466ff7e84ed1d78f4ddc561c99", + "sha256:d4f3ff613d486650816bc5516760c0382a2cc0ca8aeddd8914d011bc3b81d9a2", + "sha256:e13b9c7ff2604b0146772025e1ac6f85c8c625bf6ac73736ff671eaf357dda41", + "sha256:f5eea45851c960628a2bd29847765d55e19a687c5374456ad2c8cf6410eb1efa", + "sha256:f70bd250769381c73110d6f24feaf8b6fcd44f680b3cb28a20ea06db3d04fb6f" + ], + "markers": "python_version >= '3.8'", + "version": "==0.5.7" + }, + "typing-extensions": { + "hashes": [ + "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", + "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5" + ], + "markers": "python_version < '3.15'", + "version": "==4.16.0" + }, + "watchfiles": { + "hashes": [ + "sha256:000b9688fc8133037a8b075c8ebf98f32844ff8964dda61e85c1db547dafc441", + "sha256:025b108f2d5cc2799cb941f79380df3e8b22bfb589c218e801767fe78d598c95", + "sha256:04c5500faa725d69a99b0f63750e80795e455bb951849e9c98a811b4324997c4", + "sha256:1acabde19b67e673274e89a04d613b7fb1f122e2c4b8ec9a581e59c149264b61", + "sha256:26b81bc515a0f03f66a69a6fea86eea54c8eca4173c46dd7222569f79dd2f977", + "sha256:380f513d26cc2e598266b88d66456e07d67ef4be8f0f435a1154d9c44b43d509", + "sha256:45726c6b5a8d67c8087eb2933c4398948546d04206ef40f629dc4881d65d23d1", + "sha256:4af9c464d410e8c44b58ddf1cbec7c3a02c1cb2c6c80df9c74659ba2fbda0ab5", + "sha256:509d9f74d2bec5c1f4cd868ddcfe0c9601f7ea53066dfcb19d8ede742c4de661", + "sha256:591de392458bca26f6130fea4e667c06b657e873ad334ea06fad5a79f5086cef", + "sha256:5ec46a1ff4c1d81405a5fc645abdbff5e4e9388f7c9a6cdb392316a7c29b884f", + "sha256:6398d250994baff581147ccba846223076fe6492ca93c0d1b3588fcf5355eb5c", + "sha256:7398930a2b76b9dc67a4e6b8bfc7baf30946892a86f417a3920c07bdd6febc30", + "sha256:7c1125e99f84934a92996ae343501285617373acd66f16b59fd5654b27ad8d80", + "sha256:81c989d7267bfb7b676cd32c83bec97914e396870983cbf493e29415037bff5e", + "sha256:99aee4a07847c06820765fd7b1b49ceac4f3f711ccb7d104655a33231de1c207", + "sha256:a5b631db08fd3032db57ec6a92d1777cd60f88803287e4e941a4858c53aab1e0", + "sha256:a85e243c87109d9f48a2e0d10d6abdee8768cc114848b32281ec83d7f81d86ef", + "sha256:b5768b49e426fd5b550b012c866db347cdf15c398ef98dc557b6e6b72fa74cd1", + "sha256:bbc1198edfdc90fda0600f825aa94150f428dfcbf8138746f55998e0e660d64c", + "sha256:be9ef3cd403d756a304a0a08a112163c63da7ec72c8c9d083c98818291ff8f29", + "sha256:ca39661934749df580d89f3dde266f2af7c6968f4c21c72ce2dc387d299e6aa7", + "sha256:d36c72fcdc08f143d87316a4c4c3b064e340da2c7383d39803950740ed418935", + "sha256:d4593392e87669836670f87d62fc754059eaeb0e6157af44060a46558cebe5a3", + "sha256:d754e049006e81a9be49dc78ba7802081cee426e968cbc63ee19e164fa2d0e39", + "sha256:d978cc1dd7ba44f5590d7de74f7a9c8be7262d9e469c2c0efb8bbfc2574321dc", + "sha256:da213822ec9082b62cadf3008e07a8c690ec7a3c89f6dc5e55a8cf07b56a1b26", + "sha256:dd538c71766c59c732e2c5cedc39323c99c11897b99f93eac773438e54af206a", + "sha256:e0204f90677b7fb8d3a824279a71a01166bea9f6e53923b8056592d87b33b0b6", + "sha256:e5871d4a7f788a9f64fb06f5793389d29d171e5c32d37c3ebfd520b017cc7694", + "sha256:eb94e40b9a0db19636b5e3fed0a9803452ecc7381df13b385272abb779ee83ca", + "sha256:ec3cd4bb181a7b6329134204c2277c7144ab5f62cce9c5335d6f901ee7ce8d6a", + "sha256:f0c9865240e065a2247f4b5248528ae3d01e0e8ae071462c250c884dc16e3ee3" + ], + "index": "pypi", + "markers": "python_version >= '3.10'", + "version": "==1.3.0" + }, + "websockets": { + "hashes": [ + "sha256:0014eaff8ad5b3b43feda2279f9d34bf2eaae040720b9fbbb55944b10f40b14d", + "sha256:00679b7468b4c2b12b0757118174e8eabac56bb2f579a928a104d9554a56e098", + "sha256:00bf34b64501e3477e81fc281532ff3cbf4da26633c10b63979d5085d46602d3", + "sha256:01dcb47deebc40b38fd4a493b9b9f4d0a704b7bec6f35e4d34085b329abce71a", + "sha256:020e271205f8ab3406d7a59cd00de6dec722315924411c421bd00642f18bad86", + "sha256:0340bbef6bfbe16da888b3983d666a4db4954ac3253c38f13bc7aba0c7db5a2f", + "sha256:054c28db2dcec0e857e3b705d8c28012613e555b38c765d6a4f75340a4fc06a0", + "sha256:073c5c3f7e127041fa9d34a9e29ceefee8c3cafbd267ed2927318f425144380d", + "sha256:07fa3e7c30e2c577928d359b56bf872a3e0cbcc15553eaa0907c1ee86344b56f", + "sha256:0c84bdef916556cbe1d5a43b423398be4dd3cba6522b463e53d848578b920695", + "sha256:0c863507ada5805517ca6dff1c524dcd42942efe6304dacf06700878398d21a6", + "sha256:0c9982938980e086da59f70d05f9418cd143401a601a0faac10fa48f7bb1cd3e", + "sha256:0de501b7f2db11e83739ac20e2d33d46da4604b829f506c24be80e7def069391", + "sha256:0f4f50dfe2cc810fc4e2de979b35e83bf8bb4bccdc6fe472d93762ea7b1d5927", + "sha256:1036189bd34b0bc1b10a4679321e2c7968af317efe6e8e4c1c5141c4254fb5bb", + "sha256:10ecb38ffc05e1841b619d99c725307a223ef9ad58e7b1ed33311d472dc43918", + "sha256:12c8e2b25df59755954a04dfa09c990b96691025aaf7eafd19ed6da24b09c18d", + "sha256:12fe8984a32dbfd084e0603f1a8d740c0180cb85b3174585c54a80d2455a8394", + "sha256:17aa424ab61620aad21b36b2240efc87b500cc496e7d0e999a5c2ae99395e886", + "sha256:1a20136d61f9ca3a31493732762661fafc2c20e8861930214e21afc6a8a692a2", + "sha256:1a5cf4e7bbe3ca499e6a289206cb4fcb7444b09919e129bd517f57d5fa192c13", + "sha256:1c7ac77401227212dc6e849182feee50d57cf456ec6329ffd6979c94bb136c5c", + "sha256:1fce0f43e0d41422e0b2cad6561e1970df22f212f4c7e884967df7cf591b031c", + "sha256:259f45358c76d3b18489e3e80636cdbe807e05ecf1b10fdf1a779106d23d0c8e", + "sha256:2786cbd273ab69c22612db8a41229ddf2c158060b17b5928884bf388d07887f3", + "sha256:29176d8b429cfa0fa443c473878d37a5c06cfd0cb36b71ba4314accc71e05906", + "sha256:2a0162a6372110a5601cb5c9fd826635cedf69f3e110c545dd19774e040b970e", + "sha256:2a4dc6ef83f4559e0d05f313a375cb38f63c986096a9da99fe94fdd779d313e5", + "sha256:2afb58c7ba48b329d56769f8dfd89f394efe587b65ef806bae810a484d6d3608", + "sha256:2cce251f3e2469b99b6802b55435bcdd07123b41870f54c87b336183af9d7e68", + "sha256:2d72879819f5145a342d0030c418702496c65a4b913ef81f5ae944dd91dd50f6", + "sha256:32a2a68d989d6e5b74a9d5095415c51189ebae29fceb7cf2b64a1c0318a81256", + "sha256:33e45c7ea38428e740a7f233555d71df0b875cef7fc080acebc9654475e35335", + "sha256:34879e19bb0a3c44f9317679435aea5327fac993933a704cbf353bf1234b10c7", + "sha256:3546ef55b3a074494106508bc6505c73825970d2d9505f7bf53882b3e88b0d1e", + "sha256:3709a1ab30b4b922027d22f68d2b61a0656a91680ac894a537624e6be7dd7f7c", + "sha256:4031152769179ab8dcdeafc7b0e58052a49117560a28671700b47b2c7b717aad", + "sha256:406b8107943a43ef4649b1e0cb0cdc052bbf08fe1c8905a623c4af9586e5cebb", + "sha256:416b4bc8789a1865a3ff643ec4ee073a5f52402d0dbeafd27b1798d5dd6b6a51", + "sha256:43bd0c1ceb924d67f5c1a5254d8361dd9d94246e6331a726064dfa2917880780", + "sha256:455ffeea0879d313205df1e745e5883e1feb7f31ecd26be882f5f0babd3db04f", + "sha256:469355ab1af100b9380f1afb09985019f4a4b94fa1dd0e9396db4361626d7ab8", + "sha256:46c0331c9eaaf73a559f3a9e388466be0df96eb83d40f06f1ca6ab6613b35c82", + "sha256:46e7a10bf04318c7b0c0273791925ae5e1cbe4a11e34aa934d2ef27862058a80", + "sha256:47a62d6045c6eaa0d8f97bc2fb68b8cf90077a0cbfd4e83d6f2d2145611ee134", + "sha256:4af784f3e436f65b355c117c6497320f2b5cf6a559295cb1c4c7338e335d45cc", + "sha256:4e8ffcb486c8490a34a4cef5e4409d8da5a1cb1681e5bf7d786ce5e84aa8540d", + "sha256:50903d335bfda026c2fa11dd9aed09d8cbee0c451e3a85122a9acb041b7dc69b", + "sha256:57b39dc8541cf7ed3f639da82bf7451060483967f9e733da1f8173e4095f0642", + "sha256:581fa678ef46f4277cc8491312468e582f8ad609dbab907ba6096a08c6a0ff98", + "sha256:5a74531ce81af587f906ab42f194032388fcff8fc7938402e5917c9147a39441", + "sha256:5aefe78e6a3077fe22b5e64b04666a85a3eb8b934d40e8595a693adcbceb6f11", + "sha256:5c27336b1a0ac56569493e858497870347854372395f50483725f8cdacc5a45c", + "sha256:5d4724255fb8398acd9e583b97eb2279cec20e0bd0f9a94bf75f6056ef9f13da", + "sha256:5f051f8030a51815dc00e24bd2e5f1435af095c1cc111d747ac6e2a3620d7641", + "sha256:615746b12b26a3fd4077bc6fbeb277a1c192a45dd57b531d07ad9ed5c52a9a7a", + "sha256:617243e19a0992095956f406ee9cd3bc4ba92862d83cb1d83bb59ce574412bec", + "sha256:655a8e28010f09fd6fa317e857afab3af7647f33e41dee88fa421e92086d1090", + "sha256:65be6bda2b537fefa4b3a5ccd6ab386533ce39dd8fe62433ec90901fdc81752d", + "sha256:67258b00302a5aaf0b267771c7014b13429abd7ea17eebc4c55bd935ff101555", + "sha256:677014a073bcb1fbaa7e21144786864f16c08f856d66834f611eceb9006cbab8", + "sha256:6a8e768a048c2220697477ce2e67e4345dc9f693d0ee6af53945b5e30227c6a7", + "sha256:6da17fc94bd270f5987b10bee113461ac36a36a98b0481ddcc98056e5a90001a", + "sha256:6de9acef07e3a78e9567fcd26c29011a4da8f050b13004bbf880a0fd82a6eea5", + "sha256:6e63c01803be425ff062b7f7fc201a74def1d49fc94a2410dd17375df75936e9", + "sha256:6f42912fa9eb4cb7c7ec9fde9b3332ba339eb8a8811981043d4029599f3d950b", + "sha256:722ec21717eec6477bce582147a28acdfe034e604239466a6a95daedb863e774", + "sha256:764cf7bfa149365f32b7a0fd9fed32debdac29dd06295d5635cde1745b446cd8", + "sha256:76dd004f59115087c7b700474cb18f01325e37250032e19396c08ae41448e4b3", + "sha256:77b37cceca17291897c3c73bd30a7c7c7909593554b5da574ec852af83c1742a", + "sha256:7a72efa3bf4fa3a6669a54420a472ad056da3973d827f10e3a536da463f926c2", + "sha256:7e724f843fa6a0614aece65a7c73e51d0f4412ca41dccac13c3caf98e69536bb", + "sha256:8196d217eeca52b9235ee1f8a684a09885a5f953d5a31e80ef915bf2c5c94f9d", + "sha256:829dba1bc049779de9b332088c1a6a9858e96bd67e50b6b644a95e02b67836bc", + "sha256:84f25e099fdfe3b09f953d84698f729a1f7d1e99101b2787d7a28ed77b323750", + "sha256:87f0d5e77548b0c40c8464cdb6108792e7e53f487c6400028a4ec28a8afbe5ab", + "sha256:880069d21cc33a558dcf180924a546d1ecf8ada5be3e4e70acee87019d706a24", + "sha256:882af300d2c6a092b93767d5de03c7bb56dfb06314140c8e872d3f48e09f7b74", + "sha256:88381602e379165b66244b2ebc29f9b23ea0851fbe63ae157f91ca324f072d6f", + "sha256:88b882764ef65147a7a5ae13168dedbe225a04e2ff4858fe543f2c402f093e9c", + "sha256:88bc5138e53903a85c354e59df7ba73ce306f7b09724cef74dba121e60a88ce2", + "sha256:8d1b108bd8f5f6a8b90801f6db3b3858d5deca889acfdb8ac497bbb24e4b0edf", + "sha256:8f6c38cdcaf98a911d7acc25577f2f9e710f3a2fc2bde1563556784320196b51", + "sha256:8fbf28e639544503b7d1c96452a5e5e043e4108d89b1f3fa02910603622d19db", + "sha256:96abdecbaae746851b87c3a36cb4a661df93ca3d92f114270f79228bf1d00de6", + "sha256:98a5b2589a56a4b4f098b0a958099a4356ab904a7844f1da3841efca469af7e9", + "sha256:9ae55d24241fc055f22aea3ac924559069848bd0ad4ea065fdd72d2194685fe8", + "sha256:9f4a08ff7cb68c27b18e09223cc6304e01d0f82d5a240d251266dfd2e6e44729", + "sha256:9f4c0377a83e163a303514fdfab501dbe379bdc13e5b9312a91d112658b29dce", + "sha256:9fa1ffa08c81a4f809cdab6129f8e55bee4650b9d6d3461019dda73aacd146b6", + "sha256:a06f3b5085176763182449559e20391d7ce616a8972a9f7a33deda87ea6d4f3c", + "sha256:a62d8c424383c9dc769ff3672018df822603117e32686e567d452ed035b6fb2e", + "sha256:a7b35181a14cbfcae163b4de545d22abfd07d06c2c41ca69cfcd99251d6888ab", + "sha256:a9fe648abd1d9b89aebfa30407bfdd08a0271ec5dc7d44a4c6ccd1ce22cf562a", + "sha256:acfea4c20bf54384883ea33b1240fc1db4f52e190823a4e2b334bc3e8bfca96a", + "sha256:ad68c28a27246fed109a4409393d677b7e1388345cbbd2f5aee5c182d8506110", + "sha256:aec00f018d34c67500ff0438dc314b40277be4a1b983cbacbf53ccf7db63e257", + "sha256:b1bc819c6db90e8f91a38250a1ab4c058261871aa52d2fe36382eddedf146dee", + "sha256:b1c323fc3be1dc3f87f6c59458cb7d9e13dcbbf971d6c3f3e2bbaf58d3bfcdfe", + "sha256:b3b451fd2723ad3191a209afe6f3f4bc86c83e9a85bdc255353b91803ee6aa66", + "sha256:b65d5fe48219dc2d5e158de9e6514e75600f379cc7e37108d35f31764c155566", + "sha256:bb0efe019480a1c93e168ce96479273aaebd672fc8c350d5eed1e507ababb1b8", + "sha256:be3f0129c5654517b2abf07dcb75bb1d9479759a4ccfb569e8293579e9fc029a", + "sha256:c3241d684a76eaaef8b2dc789afde4343cd3aad55ea81e4e8ab3605b529bae51", + "sha256:c65da239a5ad553619804c1f9d65c1a0b3005381c6158ee14da2c7444cbd0c78", + "sha256:c89406fa3dcd4aa8662c6406cc5c0de1790e9614d2c3aaf03ca53a8a8ccf3405", + "sha256:ccbf3f4a9890d50b3a08ee04029fde30a03bfdeffaa19977628bf17251764e60", + "sha256:ce0305b702b20d1e1d60a9aaace6bc89970e1753565543f310d549eab22c2435", + "sha256:ce13c7d233239e739600a57d4a73c1192ad8259e655a4d55aa1a454242bc809d", + "sha256:cec1bb8f22abccc8d20f8ca63df9be41600c26c190f4b97ee86c675fd4a863a6", + "sha256:d1e2f5fa2b6d01f0d85b4f223fea7ed1d504be282a02a81bd2be4817ef7a2f03", + "sha256:d334d11398086bb5559606cb42d51c013ea7c061c7db701521392373d3c087f5", + "sha256:d411ea5ca18ac1b12c0c94be88b60c18ca641ac43bcdfdf1c9f79d46cdbe1603", + "sha256:d41ef69d5416fbc1d98cf96c37be6192d10fd101c3e0f8b3ddc36e09432b3c08", + "sha256:d58159af7835fde09c462394293c0d7aaf8fb4557d8f8e5699f5e722ccae013d", + "sha256:d7b349265fad6244013eecd99df8d83c12bf3013943e431f4fadd5bffc37db42", + "sha256:d8e83333385cac6030a5167fd18bf96cc6c58b914c308e683f05b0cf94bc8dd0", + "sha256:d9d01e8ede41fea4f5a847dad9d628355f74905f437a5b6856d67aa66d193800", + "sha256:d9fc873e239c5abeb150bc24dbd1a7af23a9254526383ce0a077f5e20adbeb19", + "sha256:db9d7ee47f3ba531e278be539af39e2c7c7d28fb94897b6cd1120d63b0ef5922", + "sha256:dc053f9e95a76213c5eb7ed95779f7daf0d2bf0e4e03073629ebfa43a033f151", + "sha256:dc2b79afc074d2f3e64b26539350f697fe1b85ea1c49ea24eb588f247b053ce1", + "sha256:dc5789e5ea182b77a38881383ada5347202a6c66f4857d054e075290e80b604b", + "sha256:dcb8d5f7edef7a399d322cf28d4c4e6f98dab64d301c8f50581a1080e5198142", + "sha256:e4bd7eacb87d8cf3ed70d6392c770a0d92441f05d7d2a3efafb5bc171d5e3067", + "sha256:e552e0037230ac16e5f568de7012041344d1b18c9feed30ec2891b8eba55af81", + "sha256:e5f5c7a893507d0e83a80b88aefd6522f7e882cd53f9722c6f23f5a020c9557c", + "sha256:e74e41f0ad12ff1e8983e349daef79d37cc8280c743ce9d134d6c74c18dab5d6", + "sha256:e78fd4b7b2c5086a38671c9c882c1e643385eccea360b5b1fda4a105e590087e", + "sha256:e8dc3fa6d6b7ead3f9de57895f41b116a28787548e066365d9d90f7356bcaad2", + "sha256:ea0ed9373b880115911d9d39634bccc95b8ce590c9c42e8589f5cacc3ef3cee2", + "sha256:edadce7a22052056fd4384543019856b34850363c9d387929f677ae01d79709c", + "sha256:eec113a5b41d124ef42ff56b0d74a6da3fd986400038eab9e58ee42a4024e837", + "sha256:f221081107b8c48184d99f7019604486376e7ef826037e70aad6b02540732c23", + "sha256:f3a1d577e081667dda7f8e5b4796e6e32f9713c93e2a3d930669519840a3c623", + "sha256:f47aafd92aa28b941180e6da8a42b0f711851b14b81a5b6bb28dbbb1fa35152c", + "sha256:f4c45ee2512d3757b5e6c67c5a34e435143f2ecb7df3324f9fd888688c45c0f4", + "sha256:f58f58b4b29bbea2a3635e2c56eff4a3adab011fe383802a9e542e31b97085fc", + "sha256:f612dc57f00c07cf4aa2673f7cbceabd654ad2457b7e639f061b794d6e11f9fd", + "sha256:f62114a54117e4948a1e414e89521f7fe1e3c2f83f2a571a06a4fc6718b0900a", + "sha256:f64e001bb7fa89b9f32cfa600bf8e9ac8ca26759d9b92ae01453ee303d9cd7b4", + "sha256:f7233eaf441a345a5943a929fd4b5ea3278f11aed35a9ed0f3106b8cb3ca846a", + "sha256:f78a3ffb1994304db2c0c4588e4d1a518079b557054fa3bb985a6f5e50ff49a3", + "sha256:f8e822efd54137d8cc8310eb64635ab827a4a6c72ff08691f38aa624776d8ecb", + "sha256:f98bf378d7a5be047a044a1a27c987a8f355e10e3b5754617dbe756248cbc5ce", + "sha256:fb88076df585b69c5761c387c0081aa87d7b9eb1b205a6535ca4777e25650d81", + "sha256:fd8f47dbf2e8adb15c847215f83436de3fdb120b51fdae0fbbdf69fd97a3ad80", + "sha256:ff3e2ba7a9f0a110b0555452e9b5a03a34e11662544e01beea15f144b48ba7b7" + ], + "version": "==17.1" + } + }, + "develop": {} +} diff --git a/README.md b/README.md index 1ac5b31..12c1195 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,115 @@ -# dmx-driver +# DMX Driver — Art-Net + serial out gateway +Host gateway that accepts led-controller-style commands and fans out DMX512 +universes to **Art-Net** devices and **serial** ports. **Fixtures** are patched +onto outputs; a led-driver-style **pattern engine** writes channel roles into +those fixtures. + +## Run (desktop) + +```bash +cd dmx-driver +pipenv install +pipenv run dev +``` + +Open **http://127.0.0.1:8080/** to manage outputs, fixtures, and play patterns. + +- Web UI / API: TCP **8080** +- Art-Net out: UDP **6454** (unicast per output) +- Serial out: raw DMX512 (break + start code 0 + 512 slots), default baud **250000** 8N2 +- Controller: WebSocket **`ws://127.0.0.1:8080/ws`** (`"v": "1"` presets/select) +- Pattern upload (led-driver parity): **`POST /patterns/upload?name=foo.py&reload=1`** with raw UTF-8 body + +Patterns receive the same **`Preset`** object as led-driver (`preset.c`, `preset.d`, +`preset.b`, …). Seed patterns: `solid`, `blink`, `pulse`. Uploaded modules land in +`./patterns/` and reload into the registry. + +Example select (fixture id or gateway name): + +```json +{ + "v": "1", + "presets": { + "wash": { "pattern": "blink", "colors": ["#FF0000"], "brightness": 200, "delay": 400 } + }, + "select": { "f1": ["wash"] } +} +``` + +## Fixtures + +Each fixture is bound to one **output**, a **start channel**, and a channel map +(roles: dimmer, red, green, blue, pan, tilt). Profiles seed the map: + +- `parcan` — dimmer, red, green, blue +- `mover` — pan, tilt, dimmer, red, green, blue + +Several fixtures may share one output universe; overlapping slots on the same +output are rejected on save. Each output has its own 512-byte buffer. + +## Settings shape + +```json +{ + "name": "dmx-gateway", + "outputs": [ + { + "id": "a1", + "type": "artnet", + "enabled": true, + "host": "192.168.1.50", + "port": 6454, + "universe": 0 + } + ], + "fixtures": [ + { + "id": "f1", + "name": "Par 1", + "output_id": "a1", + "start_channel": 1, + "profile": "parcan", + "channels": [ + {"role": "dimmer", "label": "Dimmer"}, + {"role": "red", "label": "Red"}, + {"role": "green", "label": "Green"}, + {"role": "blue", "label": "Blue"} + ] + } + ] +} +``` + +## Tests + +```bash +pipenv run test +``` + +## Pipenv scripts + +| Script | Purpose | +|--------|---------| +| `dev` | Run the gateway locally | +| `device` | watchfiles deploy to `/dev/ttyACM0` | +| `test` | Desktop framing / fixture / pattern checks | + +## Layout + +``` +dmx-driver/ +├── lib/ # artnet, dmx, serial_dmx, microdot +├── src/ +│ ├── main.py +│ ├── http_app.py +│ ├── outputs.py +│ ├── player.py +│ ├── preset.py +│ ├── controller.py +│ ├── settings.py +│ └── patterns/ # solid, blink, pulse +├── patterns/ # uploaded at runtime (gitignored) +├── tests/ +└── Pipfile +``` diff --git a/dev.py b/dev.py new file mode 100755 index 0000000..7a6d5b4 --- /dev/null +++ b/dev.py @@ -0,0 +1,70 @@ +#!/usr/bin/env python3 + +import shutil +import subprocess +import serial +import sys + + +def mpremote_base(): + """mpremote on PATH, or same interpreter as this script (e.g. pipenv venv).""" + exe = shutil.which("mpremote") + if exe: + return [exe] + return [sys.executable, "-m", "mpremote"] + + +print(sys.argv) + +commands = ["src", "lib", "ls", "reset", "follow", "test"] +port = None +if len(sys.argv) > 1 and sys.argv[1] not in commands: + port = sys.argv[1] + + +for cmd in sys.argv[1:]: + print(cmd) + match cmd: + case "src": + if port: + subprocess.call( + [*mpremote_base(), "connect", port, "fs", "cp", "-r", ".", ":"], + cwd="src", + ) + else: + print("Error: Port required for 'src' command") + case "lib": + if port: + subprocess.call( + [*mpremote_base(), "connect", port, "fs", "cp", "-r", "lib", ":"] + ) + else: + print("Error: Port required for 'lib' command") + case "ls": + if port: + subprocess.call([*mpremote_base(), "connect", port, "fs", "ls", ":"]) + else: + print("Error: Port required for 'ls' command") + case "reset": + if port: + with serial.Serial(port, baudrate=115200) as ser: + ser.write(b"\x03\x03\x04") + else: + print("Error: Port required for 'reset' command") + case "follow": + if port: + with serial.Serial(port, baudrate=115200) as ser: + while True: + if ser.in_waiting > 0: + data = ser.readline().decode("utf-8").strip() + print(data) + else: + print("Error: Port required for 'follow' command") + case "test": + if port: + # Self-contained; requires ``lib`` on device first. + subprocess.call( + [*mpremote_base(), "connect", port, "run", "tests/artnet_dmx.py"] + ) + else: + print("Error: Port required for 'test' command") diff --git a/lib/artnet.py b/lib/artnet.py new file mode 100644 index 0000000..bf78833 --- /dev/null +++ b/lib/artnet.py @@ -0,0 +1,362 @@ +# Art-Net 4 (protocol 14). MicroPython and CPython. +# UDP 6454. ArtDmx payload[0] is DMX channel 1 (no start code). + +import socket + +try: + from time import ticks_diff, ticks_ms, sleep_ms +except ImportError: + from time import sleep, time + + def ticks_ms(): + return int(time() * 1000) + + def ticks_diff(a, b): + return a - b + + def sleep_ms(ms): + sleep(ms / 1000.0) + +PORT = 6454 +HEADER = b"Art-Net\x00" +OP_POLL = 0x2000 +OP_POLL_REPLY = 0x2100 +OP_DMX = 0x5000 +PROT_VER = 14 +BROADCAST = "255.255.255.255" + + +def _u16le(n): + return bytes((n & 0xFF, (n >> 8) & 0xFF)) + + +def _pad(text, size): + raw = text.encode("ascii")[: size - 1] + return raw + b"\x00" * (size - len(raw)) + + +def _ip_bytes(ip): + if isinstance(ip, (bytes, bytearray)): + return bytes(ip[:4]) + parts = ip.split(".") + return bytes(int(p) for p in parts) + + +def port_lo(universe=0, subnet=0): + """SubUni byte: subnet in high nibble, universe in low nibble.""" + return ((subnet & 0x0F) << 4) | (universe & 0x0F) + + +def as_channels(data): + """Normalise to 512-or-fewer channel bytes (ch 1 at index 0).""" + if data is None: + return b"" + if len(data) == 513: + data = data[1:] + if len(data) > 512: + data = data[:512] + return data + + +def build_artdmx(channels, universe=0, subnet=0, net=0, sequence=1, physical=0): + data = bytearray(as_channels(channels)) + n = len(data) + if n < 2: + data.extend(b"\x00" * (2 - n)) + n = 2 + if n & 1: + data.append(0) + n += 1 + pkt = bytearray(18 + n) + pkt[0:8] = HEADER + pkt[8:10] = _u16le(OP_DMX) + pkt[10] = 0 + pkt[11] = PROT_VER + pkt[12] = sequence + pkt[13] = physical + pkt[14] = port_lo(universe, subnet) + pkt[15] = net & 0x7F + pkt[16] = (n >> 8) & 0xFF + pkt[17] = n & 0xFF + pkt[18 : 18 + n] = data + return pkt + + +def parse(packet): + """Return ('dmx', net, subuni, data), ('poll', addr_unused), or None.""" + if packet is None or len(packet) < 10 or packet[0:8] != HEADER: + return None + opcode = packet[8] | (packet[9] << 8) + if opcode == OP_DMX: + if len(packet) < 18: + return None + length = (packet[16] << 8) | packet[17] + data = packet[18 : 18 + length] + return ("dmx", packet[15] & 0x7F, packet[14], data) + if opcode == OP_POLL: + return ("poll", None) + if opcode == OP_POLL_REPLY: + return ("poll_reply", None) + return None + + +class ArtNet: + """Send and receive Art-Net on one universe. + + universe/subnet/net match the 15-bit Port-Address + (net << 8) | (subnet << 4) | universe. + """ + + def __init__( + self, + universe=0, + subnet=0, + net=0, + bind="0.0.0.0", + port=PORT, + bind_port=None, + name="esp-dmx", + ip=None, + mac=None, + ): + self.universe = universe & 0x0F + self.subnet = subnet & 0x0F + self.net = net & 0x7F + self.name = name + self.ip = ip + self.mac = mac or bytes(6) + self.sequence = 1 + self.channels = bytearray(512) + self.peers = [] + self._subuni = port_lo(self.universe, self.subnet) + + self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + try: + self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + except OSError: + pass + try: + self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) + except OSError: + pass + self.sock.bind((bind, port if bind_port is None else bind_port)) + try: + self.sock.settimeout(0) + except OSError: + self.sock.setblocking(False) + self._guess_host() + + def _guess_host(self): + try: + import network + + sta = network.WLAN(network.STA_IF) + if sta.active() and sta.isconnected(): + self.ip = sta.ifconfig()[0] + try: + self.mac = sta.config("mac") + except Exception: + pass + return + + ap = network.WLAN(network.AP_IF) + if ap.active(): + self.ip = ap.ifconfig()[0] + try: + self.mac = ap.config("mac") + except Exception: + pass + return + except (ImportError, OSError, AttributeError): + pass + if not self.ip: + self.ip = "0.0.0.0" + + def _note_peer(self, addr): + """Remember unicast Art-Net sources (QLC+) so we can reply unicast.""" + if not addr: + return + host = addr[0] if isinstance(addr, (tuple, list)) else addr + if not host or host in (self.ip, BROADCAST, "0.0.0.0"): + return + if host.split(".")[-1] == "255": + return + if host not in self.peers: + self.peers.append(host) + print("artnet peer", host) + self._unicast_poll_reply(host) + + def _announce_addrs(self, extra=None): + addrs = [BROADCAST] + if extra: + host = extra[0] if isinstance(extra, (tuple, list)) else extra + if host: + addrs.append(host) + self._guess_host() + parts = (self.ip or "").split(".") + if len(parts) == 4 and parts[0] != "0": + addrs.append(".".join(parts[:3] + ["255"])) + for p in self.peers: + addrs.append(p) + try: + import network + + sta = network.WLAN(network.STA_IF) + if sta.active() and sta.isconnected(): + gw = sta.ifconfig()[2] + if gw: + addrs.append(gw) + except Exception: + pass + seen = [] + for a in addrs: + if a and a not in seen: + seen.append(a) + return seen + + def announce(self): + """ArtPoll + ArtPollReply. Unicast to known PCs; broadcast for the rest.""" + self._guess_host() + reply = self._poll_reply_packet() + poll = bytearray(14) + poll[0:8] = HEADER + poll[8:10] = _u16le(OP_POLL) + poll[10] = 0 + poll[11] = PROT_VER + poll[12] = 0x02 + poll[13] = 0 + for host in self._announce_addrs(): + try: + self.sock.sendto(reply, (host, PORT)) + self.sock.sendto(poll, (host, PORT)) + except OSError: + pass + + def send(self, data=None, dest=BROADCAST, port=PORT): + """Send ArtDmx. data[0] is channel 1, or pass a 513-byte UART frame.""" + if data is None: + data = self.channels + pkt = build_artdmx( + data, + universe=self.universe, + subnet=self.subnet, + net=self.net, + sequence=self.sequence, + ) + self.sequence += 1 + if self.sequence > 255: + self.sequence = 1 + self.sock.sendto(pkt, (dest, port)) + + def poll(self, dest=BROADCAST, port=PORT): + """Broadcast ArtPoll so other nodes reply.""" + pkt = bytearray(14) + pkt[0:8] = HEADER + pkt[8:10] = _u16le(OP_POLL) + pkt[10] = 0 + pkt[11] = PROT_VER + pkt[12] = 0 + pkt[13] = 0 + self.sock.sendto(pkt, (dest, port)) + + def recv(self): + """Read pending UDP. Returns channel bytes for this universe, else None. + + Replies to ArtPoll so QLC+ / consoles can discover this node. + If several ArtDmx packets are queued, the latest matching one is kept. + """ + latest = None + while True: + packet, addr = self._recvfrom() + if packet is None: + break + kind = parse(packet) + if kind is None: + continue + self._note_peer(addr) + if kind[0] == "poll": + self._send_poll_reply(addr) + elif kind[0] == "dmx": + _name, net, subuni, data = kind + if net == self.net and subuni == self._subuni: + n = len(data) + if n > 512: + n = 512 + self.channels[:n] = data[:n] + if n < 512: + # leave remaining channels as last values + pass + latest = self.channels + return latest + + def apply_frame(self, frame): + """Copy current channels into a UART DMX frame (start code at [0]).""" + n = len(self.channels) + frame[1 : 1 + n] = self.channels + + def serve(self, dmx): + """Block: Art-Net in, UART DMX out. Announces to QLC+ every 2.5s.""" + self.announce() + print("artnet node", self.ip, "universe", self.universe) + last_announce = ticks_ms() + while True: + if self.recv() is not None: + self.apply_frame(dmx.frame) + dmx.send() + now = ticks_ms() + if ticks_diff(now, last_announce) >= 2500: + self.announce() + last_announce = now + sleep_ms(20) + + def close(self): + self.sock.close() + + def _recvfrom(self): + try: + return self.sock.recvfrom(2048) + except OSError: + return None, None + + def _poll_reply_packet(self): + pkt = bytearray(239) + pkt[0:8] = HEADER + pkt[8:10] = _u16le(OP_POLL_REPLY) + pkt[10:14] = _ip_bytes(self.ip) + pkt[14:16] = _u16le(PORT) + pkt[16] = 0 + pkt[17] = 1 + pkt[18] = self.net + pkt[19] = self.subnet + pkt[20] = 0x00 + pkt[21] = 0xFF + pkt[23] = 0xF0 + pkt[26:44] = _pad(self.name, 18) + pkt[44:108] = _pad(self.name + " Art-Net node", 64) + pkt[108:172] = _pad("#0001 [00] ok", 64) + pkt[173] = 1 + pkt[174] = 0x80 + pkt[182] = 0x80 + pkt[190] = self.universe + pkt[200] = 0 + mac = bytes(self.mac)[:6] + pkt[201 : 201 + len(mac)] = mac + pkt[207:211] = _ip_bytes(self.ip) + pkt[211] = 1 + pkt[212] = 0x08 + return pkt + + def _unicast_poll_reply(self, host): + try: + self.sock.sendto(self._poll_reply_packet(), (host, PORT)) + except OSError: + pass + + def _send_poll_reply(self, addr): + pkt = self._poll_reply_packet() + dests = self._announce_addrs(addr) + for host in dests: + try: + self.sock.sendto(pkt, (host, PORT)) + except OSError: + pass diff --git a/lib/dmx.py b/lib/dmx.py new file mode 100644 index 0000000..7599a9c --- /dev/null +++ b/lib/dmx.py @@ -0,0 +1,33 @@ +# DMX512 UART TX. MicroPython (ESP32) and buffer-only on CPython. + +try: + from machine import UART, Pin +except ImportError: + UART = None + Pin = None + + +class DMX: + """One DMX512 universe. UART TX on MicroPython; frame-only on CPython.""" + + def __init__(self, uart=1, tx=0, de=None): + self.frame = bytearray(513) # start code 0 + 512 slots + self.uart = None + self._de = None + if UART is None: + return + self.uart = UART(uart, tx=tx) + self.uart.init(250000, bits=8, parity=None, stop=2) + if de is not None and Pin is not None: + self._de = Pin(de, Pin.OUT) + self._de.value(0) + + def send(self): + if self.uart is None: + return + if self._de is not None: + self._de.value(1) + self.uart.sendbreak() + self.uart.write(self.frame) + if self._de is not None: + self._de.value(0) diff --git a/lib/microdot/__init__.py b/lib/microdot/__init__.py new file mode 100644 index 0000000..68cb381 --- /dev/null +++ b/lib/microdot/__init__.py @@ -0,0 +1,2 @@ +from microdot.microdot import Microdot, Request, Response, abort, redirect, \ + send_file # noqa: F401 \ No newline at end of file diff --git a/lib/microdot/helpers.py b/lib/microdot/helpers.py new file mode 100644 index 0000000..664e58c --- /dev/null +++ b/lib/microdot/helpers.py @@ -0,0 +1,8 @@ +try: + from functools import wraps +except ImportError: # pragma: no cover + # MicroPython does not currently implement functools.wraps + def wraps(wrapped): + def _(wrapper): + return wrapper + return _ diff --git a/lib/microdot/microdot.py b/lib/microdot/microdot.py new file mode 100644 index 0000000..0513f21 --- /dev/null +++ b/lib/microdot/microdot.py @@ -0,0 +1,1450 @@ +""" +microdot +-------- + +The ``microdot`` module defines a few classes that help implement HTTP-based +servers for MicroPython and standard Python. +""" +import asyncio +import io +import json +import time + +try: + from inspect import iscoroutinefunction, iscoroutine + from functools import partial + + async def invoke_handler(handler, *args, **kwargs): + """Invoke a handler and return the result. + + This method runs sync handlers in a thread pool executor. + """ + if iscoroutinefunction(handler): + ret = await handler(*args, **kwargs) + else: + ret = await asyncio.get_running_loop().run_in_executor( + None, partial(handler, *args, **kwargs)) + return ret +except ImportError: # pragma: no cover + def iscoroutine(coro): + return hasattr(coro, 'send') and hasattr(coro, 'throw') + + async def invoke_handler(handler, *args, **kwargs): + """Invoke a handler and return the result. + + This method runs sync handlers in the asyncio thread, which can + potentially cause blocking and performance issues. + """ + ret = handler(*args, **kwargs) + if iscoroutine(ret): + ret = await ret + return ret + +try: + from sys import print_exception +except ImportError: # pragma: no cover + import traceback + + def print_exception(exc): + traceback.print_exc() + +MUTED_SOCKET_ERRORS = [ + 32, # Broken pipe + 54, # Connection reset by peer + 104, # Connection reset by peer + 128, # Operation on closed socket +] + + +def urldecode_str(s): + s = s.replace('+', ' ') + parts = s.split('%') + if len(parts) == 1: + return s + result = [parts[0]] + for item in parts[1:]: + if item == '': + result.append('%') + else: + code = item[:2] + result.append(chr(int(code, 16))) + result.append(item[2:]) + return ''.join(result) + + +def urldecode_bytes(s): + s = s.replace(b'+', b' ') + parts = s.split(b'%') + if len(parts) == 1: + return s.decode() + result = [parts[0]] + for item in parts[1:]: + if item == b'': + result.append(b'%') + else: + code = item[:2] + result.append(bytes([int(code, 16)])) + result.append(item[2:]) + return b''.join(result).decode() + + +def urlencode(s): + return s.replace('+', '%2B').replace(' ', '+').replace( + '%', '%25').replace('?', '%3F').replace('#', '%23').replace( + '&', '%26').replace('=', '%3D') + + +class NoCaseDict(dict): + """A subclass of dictionary that holds case-insensitive keys. + + :param initial_dict: an initial dictionary of key/value pairs to + initialize this object with. + + Example:: + + >>> d = NoCaseDict() + >>> d['Content-Type'] = 'text/html' + >>> print(d['Content-Type']) + text/html + >>> print(d['content-type']) + text/html + >>> print(d['CONTENT-TYPE']) + text/html + >>> del d['cOnTeNt-TyPe'] + >>> print(d) + {} + """ + def __init__(self, initial_dict=None): + super().__init__(initial_dict or {}) + self.keymap = {k.lower(): k for k in self.keys() if k.lower() != k} + + def __setitem__(self, key, value): + kl = key.lower() + key = self.keymap.get(kl, key) + if kl != key: + self.keymap[kl] = key + super().__setitem__(key, value) + + def __getitem__(self, key): + kl = key.lower() + return super().__getitem__(self.keymap.get(kl, kl)) + + def __delitem__(self, key): + kl = key.lower() + super().__delitem__(self.keymap.get(kl, kl)) + + def __contains__(self, key): + kl = key.lower() + return self.keymap.get(kl, kl) in self.keys() + + def get(self, key, default=None): + kl = key.lower() + return super().get(self.keymap.get(kl, kl), default) + + def update(self, other_dict): + for key, value in other_dict.items(): + self[key] = value + + +def mro(cls): # pragma: no cover + """Return the method resolution order of a class. + + This is a helper function that returns the method resolution order of a + class. It is used by Microdot to find the best error handler to invoke for + the raised exception. + + In CPython, this function returns the ``__mro__`` attribute of the class. + In MicroPython, this function implements a recursive depth-first scanning + of the class hierarchy. + """ + if hasattr(cls, 'mro'): + return cls.__mro__ + + def _mro(cls): + m = [cls] + for base in cls.__bases__: + m += _mro(base) + return m + + mro_list = _mro(cls) + + # If a class appears multiple times (due to multiple inheritance) remove + # all but the last occurence. This matches the method resolution order + # of MicroPython, but not CPython. + mro_pruned = [] + for i in range(len(mro_list)): + base = mro_list.pop(0) + if base not in mro_list: + mro_pruned.append(base) + return mro_pruned + + +class MultiDict(dict): + """A subclass of dictionary that can hold multiple values for the same + key. It is used to hold key/value pairs decoded from query strings and + form submissions. + + :param initial_dict: an initial dictionary of key/value pairs to + initialize this object with. + + Example:: + + >>> d = MultiDict() + >>> d['sort'] = 'name' + >>> d['sort'] = 'email' + >>> print(d['sort']) + 'name' + >>> print(d.getlist('sort')) + ['name', 'email'] + """ + def __init__(self, initial_dict=None): + super().__init__() + if initial_dict: + for key, value in initial_dict.items(): + self[key] = value + + def __setitem__(self, key, value): + if key not in self: + super().__setitem__(key, []) + super().__getitem__(key).append(value) + + def __getitem__(self, key): + return super().__getitem__(key)[0] + + def get(self, key, default=None, type=None): + """Return the value for a given key. + + :param key: The key to retrieve. + :param default: A default value to use if the key does not exist. + :param type: A type conversion callable to apply to the value. + + If the multidict contains more than one value for the requested key, + this method returns the first value only. + + Example:: + + >>> d = MultiDict() + >>> d['age'] = '42' + >>> d.get('age') + '42' + >>> d.get('age', type=int) + 42 + >>> d.get('name', default='noname') + 'noname' + """ + if key not in self: + return default + value = self[key] + if type is not None: + value = type(value) + return value + + def getlist(self, key, type=None): + """Return all the values for a given key. + + :param key: The key to retrieve. + :param type: A type conversion callable to apply to the values. + + If the requested key does not exist in the dictionary, this method + returns an empty list. + + Example:: + + >>> d = MultiDict() + >>> d.getlist('items') + [] + >>> d['items'] = '3' + >>> d.getlist('items') + ['3'] + >>> d['items'] = '56' + >>> d.getlist('items') + ['3', '56'] + >>> d.getlist('items', type=int) + [3, 56] + """ + if key not in self: + return [] + values = super().__getitem__(key) + if type is not None: + values = [type(value) for value in values] + return values + + +class AsyncBytesIO: + """An async wrapper for BytesIO.""" + def __init__(self, data): + self.stream = io.BytesIO(data) + + async def read(self, n=-1): + return self.stream.read(n) + + async def readline(self): # pragma: no cover + return self.stream.readline() + + async def readexactly(self, n): # pragma: no cover + return self.stream.read(n) + + async def readuntil(self, separator=b'\n'): # pragma: no cover + return self.stream.readuntil(separator=separator) + + async def awrite(self, data): # pragma: no cover + return self.stream.write(data) + + async def aclose(self): # pragma: no cover + pass + + +class Request: + """An HTTP request.""" + #: Specify the maximum payload size that is accepted. Requests with larger + #: payloads will be rejected with a 413 status code. Applications can + #: change this maximum as necessary. + #: + #: Example:: + #: + #: Request.max_content_length = 1 * 1024 * 1024 # 1MB requests allowed + max_content_length = 16 * 1024 + + #: Specify the maximum payload size that can be stored in ``body``. + #: Requests with payloads that are larger than this size and up to + #: ``max_content_length`` bytes will be accepted, but the application will + #: only be able to access the body of the request by reading from + #: ``stream``. Set to 0 if you always access the body as a stream. + #: + #: Example:: + #: + #: Request.max_body_length = 4 * 1024 # up to 4KB bodies read + max_body_length = 16 * 1024 + + #: Specify the maximum length allowed for a line in the request. Requests + #: with longer lines will not be correctly interpreted. Applications can + #: change this maximum as necessary. + #: + #: Example:: + #: + #: Request.max_readline = 16 * 1024 # 16KB lines allowed + max_readline = 2 * 1024 + + class G: + pass + + def __init__(self, app, client_addr, method, url, http_version, headers, + body=None, stream=None, sock=None): + #: The application instance to which this request belongs. + self.app = app + #: The address of the client, as a tuple (host, port). + self.client_addr = client_addr + #: The HTTP method of the request. + self.method = method + #: The request URL, including the path and query string. + self.url = url + #: The path portion of the URL. + self.path = url + #: The query string portion of the URL. + self.query_string = None + #: The parsed query string, as a + #: :class:`MultiDict ` object. + self.args = {} + #: A dictionary with the headers included in the request. + self.headers = headers + #: A dictionary with the cookies included in the request. + self.cookies = {} + #: The parsed ``Content-Length`` header. + self.content_length = 0 + #: The parsed ``Content-Type`` header. + self.content_type = None + #: A general purpose container for applications to store data during + #: the life of the request. + self.g = Request.G() + + self.http_version = http_version + if '?' in self.path: + self.path, self.query_string = self.path.split('?', 1) + self.args = self._parse_urlencoded(self.query_string) + + if 'Content-Length' in self.headers: + self.content_length = int(self.headers['Content-Length']) + if 'Content-Type' in self.headers: + self.content_type = self.headers['Content-Type'] + if 'Cookie' in self.headers: + for cookie in self.headers['Cookie'].split(';'): + name, value = cookie.strip().split('=', 1) + self.cookies[name] = value + + self._body = body + self.body_used = False + self._stream = stream + self.sock = sock + self._json = None + self._form = None + self.after_request_handlers = [] + + @staticmethod + async def create(app, client_reader, client_writer, client_addr): + """Create a request object. + + :param app: The Microdot application instance. + :param client_reader: An input stream from where the request data can + be read. + :param client_writer: An output stream where the response data can be + written. + :param client_addr: The address of the client, as a tuple. + + This method is a coroutine. It returns a newly created ``Request`` + object. + """ + # request line + line = (await Request._safe_readline(client_reader)).strip().decode() + if not line: # pragma: no cover + return None + method, url, http_version = line.split() + http_version = http_version.split('/', 1)[1] + + # headers + headers = NoCaseDict() + content_length = 0 + while True: + line = (await Request._safe_readline( + client_reader)).strip().decode() + if line == '': + break + header, value = line.split(':', 1) + value = value.strip() + headers[header] = value + if header.lower() == 'content-length': + content_length = int(value) + + # body + body = b'' + if content_length and content_length <= Request.max_body_length: + body = await client_reader.readexactly(content_length) + stream = None + else: + body = b'' + stream = client_reader + + return Request(app, client_addr, method, url, http_version, headers, + body=body, stream=stream, + sock=(client_reader, client_writer)) + + def _parse_urlencoded(self, urlencoded): + data = MultiDict() + if len(urlencoded) > 0: # pragma: no branch + if isinstance(urlencoded, str): + for kv in [pair.split('=', 1) + for pair in urlencoded.split('&') if pair]: + data[urldecode_str(kv[0])] = urldecode_str(kv[1]) \ + if len(kv) > 1 else '' + elif isinstance(urlencoded, bytes): # pragma: no branch + for kv in [pair.split(b'=', 1) + for pair in urlencoded.split(b'&') if pair]: + data[urldecode_bytes(kv[0])] = urldecode_bytes(kv[1]) \ + if len(kv) > 1 else b'' + return data + + @property + def body(self): + """The body of the request, as bytes.""" + return self._body + + @property + def stream(self): + """The body of the request, as a bytes stream.""" + if self._stream is None: + self._stream = AsyncBytesIO(self._body) + return self._stream + + @property + def json(self): + """The parsed JSON body, or ``None`` if the request does not have a + JSON body.""" + if self._json is None: + if self.content_type is None: + return None + mime_type = self.content_type.split(';')[0] + if mime_type != 'application/json': + return None + self._json = json.loads(self.body.decode()) + return self._json + + @property + def form(self): + """The parsed form submission body, as a + :class:`MultiDict ` object, or ``None`` if the + request does not have a form submission.""" + if self._form is None: + if self.content_type is None: + return None + mime_type = self.content_type.split(';')[0] + if mime_type != 'application/x-www-form-urlencoded': + return None + self._form = self._parse_urlencoded(self.body) + return self._form + + def after_request(self, f): + """Register a request-specific function to run after the request is + handled. Request-specific after request handlers run at the very end, + after the application's own after request handlers. The function must + take two arguments, the request and response objects. The return value + of the function must be the updated response object. + + Example:: + + @app.route('/') + def index(request): + # register a request-specific after request handler + @req.after_request + def func(request, response): + # ... + return response + + return 'Hello, World!' + + Note that the function is not called if the request handler raises an + exception and an error response is returned instead. + """ + self.after_request_handlers.append(f) + return f + + @staticmethod + async def _safe_readline(stream): + line = (await stream.readline()) + if len(line) > Request.max_readline: + raise ValueError('line too long') + return line + + +class Response: + """An HTTP response class. + + :param body: The body of the response. If a dictionary or list is given, + a JSON formatter is used to generate the body. If a file-like + object or an async generator is given, a streaming response is + used. If a string is given, it is encoded from UTF-8. Else, + the body should be a byte sequence. + :param status_code: The numeric HTTP status code of the response. The + default is 200. + :param headers: A dictionary of headers to include in the response. + :param reason: A custom reason phrase to add after the status code. The + default is "OK" for responses with a 200 status code and + "N/A" for any other status codes. + """ + types_map = { + 'css': 'text/css', + 'gif': 'image/gif', + 'html': 'text/html', + 'jpg': 'image/jpeg', + 'js': 'application/javascript', + 'json': 'application/json', + 'png': 'image/png', + 'txt': 'text/plain', + } + + send_file_buffer_size = 1024 + + #: The content type to use for responses that do not explicitly define a + #: ``Content-Type`` header. + default_content_type = 'text/plain' + + #: The default cache control max age used by :meth:`send_file`. A value + #: of ``None`` means that no ``Cache-Control`` header is added. + default_send_file_max_age = None + + #: Special response used to signal that a response does not need to be + #: written to the client. Used to exit WebSocket connections cleanly. + already_handled = None + + def __init__(self, body='', status_code=200, headers=None, reason=None): + if body is None and status_code == 200: + body = '' + status_code = 204 + self.status_code = status_code + self.headers = NoCaseDict(headers or {}) + self.reason = reason + if isinstance(body, (dict, list)): + self.body = json.dumps(body).encode() + self.headers['Content-Type'] = 'application/json; charset=UTF-8' + elif isinstance(body, str): + self.body = body.encode() + else: + # this applies to bytes, file-like objects or generators + self.body = body + self.is_head = False + + def set_cookie(self, cookie, value, path=None, domain=None, expires=None, + max_age=None, secure=False, http_only=False, + partitioned=False): + """Add a cookie to the response. + + :param cookie: The cookie's name. + :param value: The cookie's value. + :param path: The cookie's path. + :param domain: The cookie's domain. + :param expires: The cookie expiration time, as a ``datetime`` object + or a correctly formatted string. + :param max_age: The cookie's ``Max-Age`` value. + :param secure: The cookie's ``secure`` flag. + :param http_only: The cookie's ``HttpOnly`` flag. + :param partitioned: Whether the cookie is partitioned. + """ + http_cookie = '{cookie}={value}'.format(cookie=cookie, value=value) + if path: + http_cookie += '; Path=' + path + if domain: + http_cookie += '; Domain=' + domain + if expires: + if isinstance(expires, str): + http_cookie += '; Expires=' + expires + else: # pragma: no cover + http_cookie += '; Expires=' + time.strftime( + '%a, %d %b %Y %H:%M:%S GMT', expires.timetuple()) + if max_age is not None: + http_cookie += '; Max-Age=' + str(max_age) + if secure: + http_cookie += '; Secure' + if http_only: + http_cookie += '; HttpOnly' + if partitioned: + http_cookie += '; Partitioned' + if 'Set-Cookie' in self.headers: + self.headers['Set-Cookie'].append(http_cookie) + else: + self.headers['Set-Cookie'] = [http_cookie] + + def delete_cookie(self, cookie, **kwargs): + """Delete a cookie. + + :param cookie: The cookie's name. + :param kwargs: Any cookie opens and flags supported by + ``set_cookie()`` except ``expires`` and ``max_age``. + """ + self.set_cookie(cookie, '', expires='Thu, 01 Jan 1970 00:00:01 GMT', + max_age=0, **kwargs) + + def complete(self): + if isinstance(self.body, bytes) and \ + 'Content-Length' not in self.headers: + self.headers['Content-Length'] = str(len(self.body)) + if 'Content-Type' not in self.headers: + self.headers['Content-Type'] = self.default_content_type + if 'charset=' not in self.headers['Content-Type']: + self.headers['Content-Type'] += '; charset=UTF-8' + + async def write(self, stream): + self.complete() + + try: + # status code + reason = self.reason if self.reason is not None else \ + ('OK' if self.status_code == 200 else 'N/A') + await stream.awrite('HTTP/1.0 {status_code} {reason}\r\n'.format( + status_code=self.status_code, reason=reason).encode()) + + # headers + for header, value in self.headers.items(): + values = value if isinstance(value, list) else [value] + for value in values: + await stream.awrite('{header}: {value}\r\n'.format( + header=header, value=value).encode()) + await stream.awrite(b'\r\n') + + # body + if not self.is_head: + iter = self.body_iter() + async for body in iter: + if isinstance(body, str): # pragma: no cover + body = body.encode() + try: + await stream.awrite(body) + except OSError as exc: # pragma: no cover + if exc.errno in MUTED_SOCKET_ERRORS or \ + exc.args[0] == 'Connection lost': + if hasattr(iter, 'aclose'): + await iter.aclose() + raise + if hasattr(iter, 'aclose'): # pragma: no branch + await iter.aclose() + + except OSError as exc: # pragma: no cover + if exc.errno in MUTED_SOCKET_ERRORS or \ + exc.args[0] == 'Connection lost': + pass + else: + raise + + def body_iter(self): + if hasattr(self.body, '__anext__'): + # response body is an async generator + return self.body + + response = self + + class iter: + ITER_UNKNOWN = 0 + ITER_SYNC_GEN = 1 + ITER_FILE_OBJ = 2 + ITER_NO_BODY = -1 + + def __aiter__(self): + if response.body: + self.i = self.ITER_UNKNOWN # need to determine type + else: + self.i = self.ITER_NO_BODY + return self + + async def __anext__(self): + if self.i == self.ITER_NO_BODY: + await self.aclose() + raise StopAsyncIteration + if self.i == self.ITER_UNKNOWN: + if hasattr(response.body, 'read'): + self.i = self.ITER_FILE_OBJ + elif hasattr(response.body, '__next__'): + self.i = self.ITER_SYNC_GEN + return next(response.body) + else: + self.i = self.ITER_NO_BODY + return response.body + elif self.i == self.ITER_SYNC_GEN: + try: + return next(response.body) + except StopIteration: + await self.aclose() + raise StopAsyncIteration + buf = response.body.read(response.send_file_buffer_size) + if iscoroutine(buf): # pragma: no cover + buf = await buf + if len(buf) < response.send_file_buffer_size: + self.i = self.ITER_NO_BODY + return buf + + async def aclose(self): + if hasattr(response.body, 'close'): + result = response.body.close() + if iscoroutine(result): # pragma: no cover + await result + + return iter() + + @classmethod + def redirect(cls, location, status_code=302): + """Return a redirect response. + + :param location: The URL to redirect to. + :param status_code: The 3xx status code to use for the redirect. The + default is 302. + """ + if '\x0d' in location or '\x0a' in location: + raise ValueError('invalid redirect URL') + return cls(status_code=status_code, headers={'Location': location}) + + @classmethod + def send_file(cls, filename, status_code=200, content_type=None, + stream=None, max_age=None, compressed=False, + file_extension=''): + """Send file contents in a response. + + :param filename: The filename of the file. + :param status_code: The 3xx status code to use for the redirect. The + default is 302. + :param content_type: The ``Content-Type`` header to use in the + response. If omitted, it is generated + automatically from the file extension of the + ``filename`` parameter. + :param stream: A file-like object to read the file contents from. If + a stream is given, the ``filename`` parameter is only + used when generating the ``Content-Type`` header. + :param max_age: The ``Cache-Control`` header's ``max-age`` value in + seconds. If omitted, the value of the + :attr:`Response.default_send_file_max_age` attribute is + used. + :param compressed: Whether the file is compressed. If ``True``, the + ``Content-Encoding`` header is set to ``gzip``. A + string with the header value can also be passed. + Note that when using this option the file must have + been compressed beforehand. This option only sets + the header. + :param file_extension: A file extension to append to the ``filename`` + parameter when opening the file, including the + dot. The extension given here is not considered + when generating the ``Content-Type`` header. + + Security note: The filename is assumed to be trusted. Never pass + filenames provided by the user without validating and sanitizing them + first. + """ + if content_type is None: + if compressed and filename.endswith('.gz'): + ext = filename[:-3].split('.')[-1] + else: + ext = filename.split('.')[-1] + if ext in Response.types_map: + content_type = Response.types_map[ext] + else: + content_type = 'application/octet-stream' + headers = {'Content-Type': content_type} + + if max_age is None: + max_age = cls.default_send_file_max_age + if max_age is not None: + headers['Cache-Control'] = 'max-age={}'.format(max_age) + + if compressed: + headers['Content-Encoding'] = compressed \ + if isinstance(compressed, str) else 'gzip' + + f = stream or open(filename + file_extension, 'rb') + return cls(body=f, status_code=status_code, headers=headers) + + +class URLPattern(): + def __init__(self, url_pattern): + self.url_pattern = url_pattern + self.segments = [] + self.regex = None + pattern = '' + use_regex = False + for segment in url_pattern.lstrip('/').split('/'): + if segment and segment[0] == '<': + if segment[-1] != '>': + raise ValueError('invalid URL pattern') + segment = segment[1:-1] + if ':' in segment: + type_, name = segment.rsplit(':', 1) + else: + type_ = 'string' + name = segment + parser = None + if type_ == 'string': + parser = self._string_segment + pattern += '/([^/]+)' + elif type_ == 'int': + parser = self._int_segment + pattern += '/(-?\\d+)' + elif type_ == 'path': + use_regex = True + pattern += '/(.+)' + elif type_.startswith('re:'): + use_regex = True + pattern += '/({pattern})'.format(pattern=type_[3:]) + else: + raise ValueError('invalid URL segment type') + self.segments.append({'parser': parser, 'name': name, + 'type': type_}) + else: + pattern += '/' + segment + self.segments.append({'parser': self._static_segment(segment)}) + if use_regex: + import re + self.regex = re.compile('^' + pattern + '$') + + def match(self, path): + args = {} + if self.regex: + g = self.regex.match(path) + if not g: + return + i = 1 + for segment in self.segments: + if 'name' not in segment: + continue + value = g.group(i) + if segment['type'] == 'int': + value = int(value) + args[segment['name']] = value + i += 1 + else: + if len(path) == 0 or path[0] != '/': + return + path = path[1:] + args = {} + for segment in self.segments: + if path is None: + return + arg, path = segment['parser'](path) + if arg is None: + return + if 'name' in segment: + args[segment['name']] = arg + if path is not None: + return + return args + + def _static_segment(self, segment): + def _static(value): + s = value.split('/', 1) + if s[0] == segment: + return '', s[1] if len(s) > 1 else None + return None, None + return _static + + def _string_segment(self, value): + s = value.split('/', 1) + if len(s[0]) == 0: + return None, None + return s[0], s[1] if len(s) > 1 else None + + def _int_segment(self, value): + s = value.split('/', 1) + try: + return int(s[0]), s[1] if len(s) > 1 else None + except ValueError: + return None, None + + +class HTTPException(Exception): + def __init__(self, status_code, reason=None): + self.status_code = status_code + self.reason = reason or str(status_code) + ' error' + + def __repr__(self): # pragma: no cover + return 'HTTPException: {}'.format(self.status_code) + + +class Microdot: + """An HTTP application class. + + This class implements an HTTP application instance and is heavily + influenced by the ``Flask`` class of the Flask framework. It is typically + declared near the start of the main application script. + + Example:: + + from microdot import Microdot + + app = Microdot() + """ + + def __init__(self): + self.url_map = [] + self.before_request_handlers = [] + self.after_request_handlers = [] + self.after_error_request_handlers = [] + self.error_handlers = {} + self.shutdown_requested = False + self.options_handler = self.default_options_handler + self.debug = False + self.server = None + + def route(self, url_pattern, methods=None): + """Decorator that is used to register a function as a request handler + for a given URL. + + :param url_pattern: The URL pattern that will be compared against + incoming requests. + :param methods: The list of HTTP methods to be handled by the + decorated function. If omitted, only ``GET`` requests + are handled. + + The URL pattern can be a static path (for example, ``/users`` or + ``/api/invoices/search``) or a path with dynamic components enclosed + in ``<`` and ``>`` (for example, ``/users/`` or + ``/invoices//products``). Dynamic path components can also + include a type prefix, separated from the name with a colon (for + example, ``/users/``). The type can be ``string`` (the + default), ``int``, ``path`` or ``re:[regular-expression]``. + + The first argument of the decorated function must be + the request object. Any path arguments that are specified in the URL + pattern are passed as keyword arguments. The return value of the + function must be a :class:`Response` instance, or the arguments to + be passed to this class. + + Example:: + + @app.route('/') + def index(request): + return 'Hello, world!' + """ + def decorated(f): + self.url_map.append( + ([m.upper() for m in (methods or ['GET'])], + URLPattern(url_pattern), f)) + return f + return decorated + + def get(self, url_pattern): + """Decorator that is used to register a function as a ``GET`` request + handler for a given URL. + + :param url_pattern: The URL pattern that will be compared against + incoming requests. + + This decorator can be used as an alias to the ``route`` decorator with + ``methods=['GET']``. + + Example:: + + @app.get('/users/') + def get_user(request, id): + # ... + """ + return self.route(url_pattern, methods=['GET']) + + def post(self, url_pattern): + """Decorator that is used to register a function as a ``POST`` request + handler for a given URL. + + :param url_pattern: The URL pattern that will be compared against + incoming requests. + + This decorator can be used as an alias to the``route`` decorator with + ``methods=['POST']``. + + Example:: + + @app.post('/users') + def create_user(request): + # ... + """ + return self.route(url_pattern, methods=['POST']) + + def put(self, url_pattern): + """Decorator that is used to register a function as a ``PUT`` request + handler for a given URL. + + :param url_pattern: The URL pattern that will be compared against + incoming requests. + + This decorator can be used as an alias to the ``route`` decorator with + ``methods=['PUT']``. + + Example:: + + @app.put('/users/') + def edit_user(request, id): + # ... + """ + return self.route(url_pattern, methods=['PUT']) + + def patch(self, url_pattern): + """Decorator that is used to register a function as a ``PATCH`` request + handler for a given URL. + + :param url_pattern: The URL pattern that will be compared against + incoming requests. + + This decorator can be used as an alias to the ``route`` decorator with + ``methods=['PATCH']``. + + Example:: + + @app.patch('/users/') + def edit_user(request, id): + # ... + """ + return self.route(url_pattern, methods=['PATCH']) + + def delete(self, url_pattern): + """Decorator that is used to register a function as a ``DELETE`` + request handler for a given URL. + + :param url_pattern: The URL pattern that will be compared against + incoming requests. + + This decorator can be used as an alias to the ``route`` decorator with + ``methods=['DELETE']``. + + Example:: + + @app.delete('/users/') + def delete_user(request, id): + # ... + """ + return self.route(url_pattern, methods=['DELETE']) + + def before_request(self, f): + """Decorator to register a function to run before each request is + handled. The decorated function must take a single argument, the + request object. + + Example:: + + @app.before_request + def func(request): + # ... + """ + self.before_request_handlers.append(f) + return f + + def after_request(self, f): + """Decorator to register a function to run after each request is + handled. The decorated function must take two arguments, the request + and response objects. The return value of the function must be an + updated response object. + + Example:: + + @app.after_request + def func(request, response): + # ... + return response + """ + self.after_request_handlers.append(f) + return f + + def after_error_request(self, f): + """Decorator to register a function to run after an error response is + generated. The decorated function must take two arguments, the request + and response objects. The return value of the function must be an + updated response object. The handler is invoked for error responses + generated by Microdot, as well as those returned by application-defined + error handlers. + + Example:: + + @app.after_error_request + def func(request, response): + # ... + return response + """ + self.after_error_request_handlers.append(f) + return f + + def errorhandler(self, status_code_or_exception_class): + """Decorator to register a function as an error handler. Error handler + functions for numeric HTTP status codes must accept a single argument, + the request object. Error handler functions for Python exceptions + must accept two arguments, the request object and the exception + object. + + :param status_code_or_exception_class: The numeric HTTP status code or + Python exception class to + handle. + + Examples:: + + @app.errorhandler(404) + def not_found(request): + return 'Not found' + + @app.errorhandler(RuntimeError) + def runtime_error(request, exception): + return 'Runtime error' + """ + def decorated(f): + self.error_handlers[status_code_or_exception_class] = f + return f + return decorated + + def mount(self, subapp, url_prefix=''): + """Mount a sub-application, optionally under the given URL prefix. + + :param subapp: The sub-application to mount. + :param url_prefix: The URL prefix to mount the application under. + """ + for methods, pattern, handler in subapp.url_map: + self.url_map.append( + (methods, URLPattern(url_prefix + pattern.url_pattern), + handler)) + for handler in subapp.before_request_handlers: + self.before_request_handlers.append(handler) + for handler in subapp.after_request_handlers: + self.after_request_handlers.append(handler) + for handler in subapp.after_error_request_handlers: + self.after_error_request_handlers.append(handler) + for status_code, handler in subapp.error_handlers.items(): + self.error_handlers[status_code] = handler + + @staticmethod + def abort(status_code, reason=None): + """Abort the current request and return an error response with the + given status code. + + :param status_code: The numeric status code of the response. + :param reason: The reason for the response, which is included in the + response body. + + Example:: + + from microdot import abort + + @app.route('/users/') + def get_user(id): + user = get_user_by_id(id) + if user is None: + abort(404) + return user.to_dict() + """ + raise HTTPException(status_code, reason) + + async def start_server(self, host='0.0.0.0', port=5000, debug=False, + ssl=None): + """Start the Microdot web server as a coroutine. This coroutine does + not normally return, as the server enters an endless listening loop. + The :func:`shutdown` function provides a method for terminating the + server gracefully. + + :param host: The hostname or IP address of the network interface that + will be listening for requests. A value of ``'0.0.0.0'`` + (the default) indicates that the server should listen for + requests on all the available interfaces, and a value of + ``127.0.0.1`` indicates that the server should listen + for requests only on the internal networking interface of + the host. + :param port: The port number to listen for requests. The default is + port 5000. + :param debug: If ``True``, the server logs debugging information. The + default is ``False``. + :param ssl: An ``SSLContext`` instance or ``None`` if the server should + not use TLS. The default is ``None``. + + This method is a coroutine. + + Example:: + + import asyncio + from microdot import Microdot + + app = Microdot() + + @app.route('/') + async def index(request): + return 'Hello, world!' + + async def main(): + await app.start_server(debug=True) + + asyncio.run(main()) + """ + self.debug = debug + + async def serve(reader, writer): + if not hasattr(writer, 'awrite'): # pragma: no cover + # CPython provides the awrite and aclose methods in 3.8+ + async def awrite(self, data): + self.write(data) + await self.drain() + + async def aclose(self): + self.close() + await self.wait_closed() + + from types import MethodType + writer.awrite = MethodType(awrite, writer) + writer.aclose = MethodType(aclose, writer) + + await self.handle_request(reader, writer) + + if self.debug: # pragma: no cover + print('Starting async server on {host}:{port}...'.format( + host=host, port=port)) + + try: + self.server = await asyncio.start_server(serve, host, port, + ssl=ssl) + except TypeError: # pragma: no cover + self.server = await asyncio.start_server(serve, host, port) + + while True: + try: + if hasattr(self.server, 'serve_forever'): # pragma: no cover + try: + await self.server.serve_forever() + except asyncio.CancelledError: + pass + await self.server.wait_closed() + break + except AttributeError: # pragma: no cover + # the task hasn't been initialized in the server object yet + # wait a bit and try again + await asyncio.sleep(0.1) + + def run(self, host='0.0.0.0', port=5000, debug=False, ssl=None): + """Start the web server. This function does not normally return, as + the server enters an endless listening loop. The :func:`shutdown` + function provides a method for terminating the server gracefully. + + :param host: The hostname or IP address of the network interface that + will be listening for requests. A value of ``'0.0.0.0'`` + (the default) indicates that the server should listen for + requests on all the available interfaces, and a value of + ``127.0.0.1`` indicates that the server should listen + for requests only on the internal networking interface of + the host. + :param port: The port number to listen for requests. The default is + port 5000. + :param debug: If ``True``, the server logs debugging information. The + default is ``False``. + :param ssl: An ``SSLContext`` instance or ``None`` if the server should + not use TLS. The default is ``None``. + + Example:: + + from microdot import Microdot + + app = Microdot() + + @app.route('/') + async def index(request): + return 'Hello, world!' + + app.run(debug=True) + """ + asyncio.run(self.start_server(host=host, port=port, debug=debug, + ssl=ssl)) # pragma: no cover + + def shutdown(self): + """Request a server shutdown. The server will then exit its request + listening loop and the :func:`run` function will return. This function + can be safely called from a route handler, as it only schedules the + server to terminate as soon as the request completes. + + Example:: + + @app.route('/shutdown') + def shutdown(request): + request.app.shutdown() + return 'The server is shutting down...' + """ + self.server.close() + + def find_route(self, req): + method = req.method.upper() + if method == 'OPTIONS' and self.options_handler: + return self.options_handler(req) + if method == 'HEAD': + method = 'GET' + f = 404 + for route_methods, route_pattern, route_handler in self.url_map: + req.url_args = route_pattern.match(req.path) + if req.url_args is not None: + if method in route_methods: + f = route_handler + break + else: + f = 405 + return f + + def default_options_handler(self, req): + allow = [] + for route_methods, route_pattern, route_handler in self.url_map: + if route_pattern.match(req.path) is not None: + allow.extend(route_methods) + if 'GET' in allow: + allow.append('HEAD') + allow.append('OPTIONS') + return {'Allow': ', '.join(allow)} + + async def handle_request(self, reader, writer): + req = None + try: + req = await Request.create(self, reader, writer, + writer.get_extra_info('peername')) + except Exception as exc: # pragma: no cover + print_exception(exc) + + res = await self.dispatch_request(req) + if res != Response.already_handled: # pragma: no branch + await res.write(writer) + try: + await writer.aclose() + except OSError as exc: # pragma: no cover + if exc.errno in MUTED_SOCKET_ERRORS: + pass + else: + raise + if self.debug and req: # pragma: no cover + print('{method} {path} {status_code}'.format( + method=req.method, path=req.path, + status_code=res.status_code)) + + async def dispatch_request(self, req): + after_request_handled = False + if req: + if req.content_length > req.max_content_length: + if 413 in self.error_handlers: + res = await invoke_handler(self.error_handlers[413], req) + else: + res = 'Payload too large', 413 + else: + f = self.find_route(req) + try: + res = None + if callable(f): + for handler in self.before_request_handlers: + res = await invoke_handler(handler, req) + if res: + break + if res is None: + res = await invoke_handler( + f, req, **req.url_args) + if isinstance(res, int): + res = '', res + if isinstance(res, tuple): + if isinstance(res[0], int): + res = ('', res[0], + res[1] if len(res) > 1 else {}) + body = res[0] + if isinstance(res[1], int): + status_code = res[1] + headers = res[2] if len(res) > 2 else {} + else: + status_code = 200 + headers = res[1] + res = Response(body, status_code, headers) + elif not isinstance(res, Response): + res = Response(res) + for handler in self.after_request_handlers: + res = await invoke_handler( + handler, req, res) or res + for handler in req.after_request_handlers: + res = await invoke_handler( + handler, req, res) or res + after_request_handled = True + elif isinstance(f, dict): + res = Response(headers=f) + elif f in self.error_handlers: + res = await invoke_handler(self.error_handlers[f], req) + else: + res = 'Not found', f + except HTTPException as exc: + if exc.status_code in self.error_handlers: + res = self.error_handlers[exc.status_code](req) + else: + res = exc.reason, exc.status_code + except Exception as exc: + print_exception(exc) + exc_class = None + res = None + if exc.__class__ in self.error_handlers: + exc_class = exc.__class__ + else: + for c in mro(exc.__class__)[1:]: + if c in self.error_handlers: + exc_class = c + break + if exc_class: + try: + res = await invoke_handler( + self.error_handlers[exc_class], req, exc) + except Exception as exc2: # pragma: no cover + print_exception(exc2) + if res is None: + if 500 in self.error_handlers: + res = await invoke_handler( + self.error_handlers[500], req) + else: + res = 'Internal server error', 500 + else: + if 400 in self.error_handlers: + res = await invoke_handler(self.error_handlers[400], req) + else: + res = 'Bad request', 400 + if isinstance(res, tuple): + res = Response(*res) + elif not isinstance(res, Response): + res = Response(res) + if not after_request_handled: + for handler in self.after_error_request_handlers: + res = await invoke_handler( + handler, req, res) or res + res.is_head = (req and req.method == 'HEAD') + return res + + +Response.already_handled = Response() + +abort = Microdot.abort +redirect = Response.redirect +send_file = Response.send_file \ No newline at end of file diff --git a/lib/microdot/utemplate.py b/lib/microdot/utemplate.py new file mode 100644 index 0000000..16d0398 --- /dev/null +++ b/lib/microdot/utemplate.py @@ -0,0 +1,70 @@ +from utemplate import recompile + +_loader = None + + +class Template: + """A template object. + + :param template: The filename of the template to render, relative to the + configured template directory. + """ + @classmethod + def initialize(cls, template_dir='templates', + loader_class=recompile.Loader): + """Initialize the templating subsystem. + + :param template_dir: the directory where templates are stored. This + argument is optional. The default is to load + templates from a *templates* subdirectory. + :param loader_class: the ``utemplate.Loader`` class to use when loading + templates. This argument is optional. The default + is the ``recompile.Loader`` class, which + automatically recompiles templates when they + change. + """ + global _loader + _loader = loader_class(None, template_dir) + + def __init__(self, template): + if _loader is None: # pragma: no cover + self.initialize() + #: The name of the template + self.name = template + self.template = _loader.load(template) + + def generate(self, *args, **kwargs): + """Return a generator that renders the template in chunks, with the + given arguments.""" + return self.template(*args, **kwargs) + + def render(self, *args, **kwargs): + """Render the template with the given arguments and return it as a + string.""" + return ''.join(self.generate(*args, **kwargs)) + + def generate_async(self, *args, **kwargs): + """Return an asynchronous generator that renders the template in + chunks, using the given arguments.""" + class sync_to_async_iter(): + def __init__(self, iter): + self.iter = iter + + def __aiter__(self): + return self + + async def __anext__(self): + try: + return next(self.iter) + except StopIteration: + raise StopAsyncIteration + + return sync_to_async_iter(self.generate(*args, **kwargs)) + + async def render_async(self, *args, **kwargs): + """Render the template with the given arguments asynchronously and + return it as a string.""" + response = '' + async for chunk in self.generate_async(*args, **kwargs): + response += chunk + return response diff --git a/lib/microdot/websocket.py b/lib/microdot/websocket.py new file mode 100644 index 0000000..0fb6f7c --- /dev/null +++ b/lib/microdot/websocket.py @@ -0,0 +1,231 @@ +import binascii +import hashlib +from microdot import Request, Response +from microdot.microdot import MUTED_SOCKET_ERRORS, print_exception +from microdot.helpers import wraps + + +class WebSocketError(Exception): + """Exception raised when an error occurs in a WebSocket connection.""" + pass + + +class WebSocket: + """A WebSocket connection object. + + An instance of this class is sent to handler functions to manage the + WebSocket connection. + """ + CONT = 0 + TEXT = 1 + BINARY = 2 + CLOSE = 8 + PING = 9 + PONG = 10 + + #: Specify the maximum message size that can be received when calling the + #: ``receive()`` method. Messages with payloads that are larger than this + #: size will be rejected and the connection closed. Set to 0 to disable + #: the size check (be aware of potential security issues if you do this), + #: or to -1 to use the value set in + #: ``Request.max_body_length``. The default is -1. + #: + #: Example:: + #: + #: WebSocket.max_message_length = 4 * 1024 # up to 4KB messages + max_message_length = -1 + + def __init__(self, request): + self.request = request + self.closed = False + + async def handshake(self): + response = self._handshake_response() + await self.request.sock[1].awrite( + b'HTTP/1.1 101 Switching Protocols\r\n') + await self.request.sock[1].awrite(b'Upgrade: websocket\r\n') + await self.request.sock[1].awrite(b'Connection: Upgrade\r\n') + await self.request.sock[1].awrite( + b'Sec-WebSocket-Accept: ' + response + b'\r\n\r\n') + + async def receive(self): + """Receive a message from the client.""" + while True: + opcode, payload = await self._read_frame() + send_opcode, data = self._process_websocket_frame(opcode, payload) + if send_opcode: # pragma: no cover + await self.send(data, send_opcode) + elif data: # pragma: no branch + return data + + async def send(self, data, opcode=None): + """Send a message to the client. + + :param data: the data to send, given as a string or bytes. + :param opcode: a custom frame opcode to use. If not given, the opcode + is ``TEXT`` or ``BINARY`` depending on the type of the + data. + """ + frame = self._encode_websocket_frame( + opcode or (self.TEXT if isinstance(data, str) else self.BINARY), + data) + await self.request.sock[1].awrite(frame) + + async def close(self): + """Close the websocket connection.""" + if not self.closed: # pragma: no cover + self.closed = True + await self.send(b'', self.CLOSE) + + def _handshake_response(self): + connection = False + upgrade = False + websocket_key = None + for header, value in self.request.headers.items(): + h = header.lower() + if h == 'connection': + connection = True + if 'upgrade' not in value.lower(): + return self.request.app.abort(400) + elif h == 'upgrade': + upgrade = True + if not value.lower() == 'websocket': + return self.request.app.abort(400) + elif h == 'sec-websocket-key': + websocket_key = value + if not connection or not upgrade or not websocket_key: + return self.request.app.abort(400) + d = hashlib.sha1(websocket_key.encode()) + d.update(b'258EAFA5-E914-47DA-95CA-C5AB0DC85B11') + return binascii.b2a_base64(d.digest())[:-1] + + @classmethod + def _parse_frame_header(cls, header): + fin = header[0] & 0x80 + opcode = header[0] & 0x0f + if fin == 0 or opcode == cls.CONT: # pragma: no cover + raise WebSocketError('Continuation frames not supported') + has_mask = header[1] & 0x80 + length = header[1] & 0x7f + if length == 126: + length = -2 + elif length == 127: + length = -8 + return fin, opcode, has_mask, length + + def _process_websocket_frame(self, opcode, payload): + if opcode == self.TEXT: + payload = payload.decode() + elif opcode == self.BINARY: + pass + elif opcode == self.CLOSE: + raise WebSocketError('Websocket connection closed') + elif opcode == self.PING: + return self.PONG, payload + elif opcode == self.PONG: # pragma: no branch + return None, None + return None, payload + + @classmethod + def _encode_websocket_frame(cls, opcode, payload): + frame = bytearray() + frame.append(0x80 | opcode) + if opcode == cls.TEXT: + payload = payload.encode() + if len(payload) < 126: + frame.append(len(payload)) + elif len(payload) < (1 << 16): + frame.append(126) + frame.extend(len(payload).to_bytes(2, 'big')) + else: + frame.append(127) + frame.extend(len(payload).to_bytes(8, 'big')) + frame.extend(payload) + return frame + + async def _read_frame(self): + header = await self.request.sock[0].read(2) + if len(header) != 2: # pragma: no cover + raise WebSocketError('Websocket connection closed') + fin, opcode, has_mask, length = self._parse_frame_header(header) + if length == -2: + length = await self.request.sock[0].read(2) + length = int.from_bytes(length, 'big') + elif length == -8: + length = await self.request.sock[0].read(8) + length = int.from_bytes(length, 'big') + max_allowed_length = Request.max_body_length \ + if self.max_message_length == -1 else self.max_message_length + if length > max_allowed_length: + raise WebSocketError('Message too large') + if has_mask: # pragma: no cover + mask = await self.request.sock[0].read(4) + payload = await self.request.sock[0].read(length) + if has_mask: # pragma: no cover + payload = bytes(x ^ mask[i % 4] for i, x in enumerate(payload)) + return opcode, payload + + +async def websocket_upgrade(request): + """Upgrade a request handler to a websocket connection. + + This function can be called directly inside a route function to process a + WebSocket upgrade handshake, for example after the user's credentials are + verified. The function returns the websocket object:: + + @app.route('/echo') + async def echo(request): + if not authenticate_user(request): + abort(401) + ws = await websocket_upgrade(request) + while True: + message = await ws.receive() + await ws.send(message) + """ + ws = WebSocket(request) + await ws.handshake() + + @request.after_request + async def after_request(request, response): + return Response.already_handled + + return ws + + +def websocket_wrapper(f, upgrade_function): + @wraps(f) + async def wrapper(request, *args, **kwargs): + ws = await upgrade_function(request) + try: + await f(request, ws, *args, **kwargs) + except OSError as exc: + if exc.errno not in MUTED_SOCKET_ERRORS: # pragma: no cover + raise + except WebSocketError: + pass + except Exception as exc: + print_exception(exc) + finally: # pragma: no cover + try: + await ws.close() + except Exception: + pass + return Response.already_handled + return wrapper + + +def with_websocket(f): + """Decorator to make a route a WebSocket endpoint. + + This decorator is used to define a route that accepts websocket + connections. The route then receives a websocket object as a second + argument that it can use to send and receive messages:: + + @app.route('/echo') + @with_websocket + async def echo(request, ws): + while True: + message = await ws.receive() + await ws.send(message) + """ + return websocket_wrapper(f, websocket_upgrade) diff --git a/lib/serial_dmx.py b/lib/serial_dmx.py new file mode 100644 index 0000000..e255e24 --- /dev/null +++ b/lib/serial_dmx.py @@ -0,0 +1,72 @@ +# Host pyserial DMX512 TX (break + 513-byte frame). No-op without pyserial. + +try: + from time import sleep +except ImportError: # pragma: no cover + def sleep(_s): + pass + +try: + import serial as pyserial +except ImportError: + pyserial = None + + +class SerialDMX: + """Raw DMX512 over a serial port (8N2, break, start code 0 + 512 slots).""" + + def __init__(self, path, baud=250000): + self.path = path + self.baud = int(baud or 250000) + self.ser = None + self.open() + + def open(self): + self.close() + if pyserial is None: + print("serial_dmx: pyserial not available, skip", self.path) + return + try: + self.ser = pyserial.Serial( + self.path, + baudrate=self.baud, + bytesize=pyserial.EIGHTBITS, + parity=pyserial.PARITY_NONE, + stopbits=pyserial.STOPBITS_TWO, + timeout=0, + write_timeout=0.5, + ) + except Exception as e: + print("serial_dmx open failed", self.path, e) + self.ser = None + + def close(self): + if self.ser is None: + return + try: + self.ser.close() + except Exception: + pass + self.ser = None + + def send(self, channels): + """Send one universe. ``channels`` is 512 bytes (ch1 at [0]) or a 513-byte frame.""" + if self.ser is None: + return + if channels is None: + return + if len(channels) == 513: + frame = channels + else: + frame = bytearray(513) + n = len(channels) + if n > 512: + n = 512 + frame[1 : 1 + n] = channels[:n] + try: + # DMX break ≥88 µs; pyserial send_break duration is in seconds. + self.ser.send_break(duration=0.0001) + sleep(0.000012) # mark after break + self.ser.write(frame) + except Exception as e: + print("serial_dmx send failed", self.path, e) diff --git a/lib/utemplate/__init__.py b/lib/utemplate/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/utemplate/compiled.py b/lib/utemplate/compiled.py new file mode 100644 index 0000000..006e6f5 --- /dev/null +++ b/lib/utemplate/compiled.py @@ -0,0 +1,14 @@ +class Loader: + + def __init__(self, pkg, dir): + if dir == ".": + dir = "" + else: + dir = dir.replace("/", ".") + "." + if pkg and pkg != "__main__": + dir = pkg + "." + dir + self.p = dir + + def load(self, name): + name = name.replace(".", "_") + return __import__(self.p + name, None, None, (name,)).render \ No newline at end of file diff --git a/lib/utemplate/recompile.py b/lib/utemplate/recompile.py new file mode 100644 index 0000000..b9bae4e --- /dev/null +++ b/lib/utemplate/recompile.py @@ -0,0 +1,21 @@ +# (c) 2014-2020 Paul Sokolovsky. MIT license. +try: + from uos import stat, remove +except: + from os import stat, remove +from . import source + + +class Loader(source.Loader): + + def load(self, name): + o_path = self.pkg_path + self.compiled_path(name) + i_path = self.pkg_path + self.dir + "/" + name + try: + o_stat = stat(o_path) + i_stat = stat(i_path) + if i_stat[8] > o_stat[8]: + # input file is newer, remove output to force recompile + remove(o_path) + finally: + return super().load(name) \ No newline at end of file diff --git a/lib/utemplate/source.py b/lib/utemplate/source.py new file mode 100644 index 0000000..0ff4651 --- /dev/null +++ b/lib/utemplate/source.py @@ -0,0 +1,188 @@ +# (c) 2014-2019 Paul Sokolovsky. MIT license. +from . import compiled + + +class Compiler: + + START_CHAR = "{" + STMNT = "%" + STMNT_END = "%}" + EXPR = "{" + EXPR_END = "}}" + + def __init__(self, file_in, file_out, indent=0, seq=0, loader=None): + self.file_in = file_in + self.file_out = file_out + self.loader = loader + self.seq = seq + self._indent = indent + self.stack = [] + self.in_literal = False + self.flushed_header = False + self.args = "*a, **d" + + def indent(self, adjust=0): + if not self.flushed_header: + self.flushed_header = True + self.indent() + self.file_out.write("def render%s(%s):\n" % (str(self.seq) if self.seq else "", self.args)) + self.stack.append("def") + self.file_out.write(" " * (len(self.stack) + self._indent + adjust)) + + def literal(self, s): + if not s: + return + if not self.in_literal: + self.indent() + self.file_out.write('yield """') + self.in_literal = True + self.file_out.write(s.replace('"', '\\"')) + + def close_literal(self): + if self.in_literal: + self.file_out.write('"""\n') + self.in_literal = False + + def render_expr(self, e): + self.indent() + self.file_out.write('yield str(' + e + ')\n') + + def parse_statement(self, stmt): + tokens = stmt.split(None, 1) + if tokens[0] == "args": + if len(tokens) > 1: + self.args = tokens[1] + else: + self.args = "" + elif tokens[0] == "set": + self.indent() + self.file_out.write(stmt[3:].strip() + "\n") + elif tokens[0] == "include": + if not self.flushed_header: + # If there was no other output, we still need a header now + self.indent() + tokens = tokens[1].split(None, 1) + args = "" + if len(tokens) > 1: + args = tokens[1] + if tokens[0][0] == "{": + self.indent() + # "1" as fromlist param is uPy hack + self.file_out.write('_ = __import__(%s.replace(".", "_"), None, None, 1)\n' % tokens[0][2:-2]) + self.indent() + self.file_out.write("yield from _.render(%s)\n" % args) + return + + with self.loader.input_open(tokens[0][1:-1]) as inc: + self.seq += 1 + c = Compiler(inc, self.file_out, len(self.stack) + self._indent, self.seq) + inc_id = self.seq + self.seq = c.compile() + self.indent() + self.file_out.write("yield from render%d(%s)\n" % (inc_id, args)) + elif len(tokens) > 1: + if tokens[0] == "elif": + assert self.stack[-1] == "if" + self.indent(-1) + self.file_out.write(stmt + ":\n") + else: + self.indent() + self.file_out.write(stmt + ":\n") + self.stack.append(tokens[0]) + else: + if stmt.startswith("end"): + assert self.stack[-1] == stmt[3:] + self.stack.pop(-1) + elif stmt == "else": + assert self.stack[-1] == "if" + self.indent(-1) + self.file_out.write("else:\n") + else: + assert False + + def parse_line(self, l): + while l: + start = l.find(self.START_CHAR) + if start == -1: + self.literal(l) + return + self.literal(l[:start]) + self.close_literal() + sel = l[start + 1] + #print("*%s=%s=" % (sel, EXPR)) + if sel == self.STMNT: + end = l.find(self.STMNT_END) + assert end > 0 + stmt = l[start + len(self.START_CHAR + self.STMNT):end].strip() + self.parse_statement(stmt) + end += len(self.STMNT_END) + l = l[end:] + if not self.in_literal and l == "\n": + break + elif sel == self.EXPR: + # print("EXPR") + end = l.find(self.EXPR_END) + assert end > 0 + expr = l[start + len(self.START_CHAR + self.EXPR):end].strip() + self.render_expr(expr) + end += len(self.EXPR_END) + l = l[end:] + else: + self.literal(l[start]) + l = l[start + 1:] + + def header(self): + self.file_out.write("# Autogenerated file\n") + + def compile(self): + self.header() + for l in self.file_in: + self.parse_line(l) + self.close_literal() + return self.seq + + +class Loader(compiled.Loader): + + def __init__(self, pkg, dir): + super().__init__(pkg, dir) + self.dir = dir + if pkg == "__main__": + # if pkg isn't really a package, don't bother to use it + # it means we're running from "filesystem directory", not + # from a package. + pkg = None + + self.pkg_path = "" + if pkg: + p = __import__(pkg) + if isinstance(p.__path__, str): + # uPy + self.pkg_path = p.__path__ + else: + # CPy + self.pkg_path = p.__path__[0] + self.pkg_path += "/" + + def input_open(self, template): + path = self.pkg_path + self.dir + "/" + template + return open(path) + + def compiled_path(self, template): + return self.dir + "/" + template.replace(".", "_") + ".py" + + def load(self, name): + try: + return super().load(name) + except (OSError, ImportError): + pass + + compiled_path = self.pkg_path + self.compiled_path(name) + + f_in = self.input_open(name) + f_out = open(compiled_path, "w") + c = Compiler(f_in, f_out, loader=self) + c.compile() + f_in.close() + f_out.close() + return super().load(name) \ No newline at end of file diff --git a/src/controller.py b/src/controller.py new file mode 100644 index 0000000..7e29b2e --- /dev/null +++ b/src/controller.py @@ -0,0 +1,140 @@ +# led-driver-style v1 message handler → PatternPlayer / solid smoke path. + +import json + +from preset import Preset + + +def _expand(msg): + if not isinstance(msg, dict): + return {} + out = dict(msg) + if "p" in msg and "presets" not in out: + out["presets"] = msg["p"] + if "s" in msg and "select" not in out: + out["select"] = msg["s"] + if "c" in msg and "colors" not in out: + out["colors"] = msg["c"] + if "b" in msg and "brightness" not in out: + out["brightness"] = msg["b"] + return out + + +def _preset_from_map(presets, preset_id): + if not isinstance(presets, dict) or preset_id is None: + return None, None + key = preset_id + data = presets.get(str(key)) + if data is None: + try: + data = presets.get(int(key)) + key = int(key) + except (TypeError, ValueError): + pass + if not isinstance(data, dict): + return None, None + return Preset(data), str(key) + + +def _select_entries(select): + """Yield (select_key, preset_id) from a select field.""" + if isinstance(select, dict): + for key, val in select.items(): + pid = val + if isinstance(pid, (list, tuple)) and pid: + pid = pid[0] + yield str(key), pid + elif isinstance(select, (list, tuple)) and select: + yield None, select[0] + elif isinstance(select, str): + yield None, select + + +def _targets_for_key(key, settings): + """None = all fixtures; list of ids = subset; False = no match.""" + name = (settings.get("name") if settings else None) or "dmx-gateway" + fixtures = settings.get("fixtures") or [] + if key is None: + return None + if key == name or (isinstance(key, str) and name in key): + return None + matched = [] + for fix in fixtures: + if key == fix.get("id") or key == fix.get("name"): + matched.append(fix["id"]) + if matched: + return matched + return False + + +def process_data(raw, settings, outputs, player=None): + """Apply a controller message. + + With a player: presets/select drive PatternPlayer with a Preset object. + Top-level colours/brightness still do a one-shot set_rgb smoke write. + """ + if raw is None: + return + if isinstance(raw, (bytes, bytearray)): + try: + raw = raw.decode("utf-8") + except UnicodeError: + return + if isinstance(raw, str): + raw = raw.strip() + if not raw: + return + try: + msg = json.loads(raw) + except ValueError: + print("controller: bad JSON") + return + elif isinstance(raw, dict): + msg = raw + else: + return + + msg = _expand(msg) + presets_map = msg.get("presets") if isinstance(msg.get("presets"), dict) else {} + + if player is not None and presets_map and player.preset_id is not None: + data = presets_map.get(str(player.preset_id)) + if data is None: + try: + data = presets_map.get(int(player.preset_id)) + except (TypeError, ValueError): + data = None + if isinstance(data, dict): + player.edit_active(data, preset_id=player.preset_id) + + if player is not None and "select" in msg: + for key, preset_id in _select_entries(msg.get("select")): + targets = _targets_for_key(key, settings) + if targets is False: + continue + preset, pid = _preset_from_map(presets_map, preset_id) + if preset is None: + # select without presets in this message: keep pattern id only if bare + if isinstance(preset_id, dict): + preset = Preset(preset_id) + pid = None + else: + continue + player.select(preset, targets=targets, preset_id=pid) + print("play", preset.p, "targets", targets if targets is not None else "all") + + # One-shot solid path (smoke / legacy) + colours = msg.get("colors") + brightness = msg.get("brightness") if "brightness" in msg else None + if colours is not None or brightness is not None: + data = {} + if colours is not None: + data["colors"] = colours + if brightness is not None: + data["brightness"] = brightness + data.setdefault("pattern", "solid") + p = Preset(data) + r, g, b = (p.c[0] if p.c else (255, 255, 255)) + dimmer = p.b if brightness is not None else 255 + outputs.set_rgb(r, g, b, dimmer) + print("channels rgb", r, g, b, "dimmer", dimmer) diff --git a/src/http_app.py b/src/http_app.py new file mode 100644 index 0000000..9264fd5 --- /dev/null +++ b/src/http_app.py @@ -0,0 +1,710 @@ +# Microdot HTTP + WebSocket for the DMX gateway. + +import glob +import json +import os + +from microdot import Microdot, Response +from microdot.websocket import WebSocketError, with_websocket + +from controller import process_data +from preset import Preset +from player import safe_pattern_filename +from settings import PROFILE_CHANNELS, ALLOWED_ROLES + + +INDEX_HTML = """ + + + + + DMX gateway + + + +

DMX gateway

+

Art-Net and serial outputs, fixtures, and patterns. Controller: /ws.

+ +
+

Device

+ + + +
+ +
+

Outputs

+ + + +
IdTypeTargetOn
+ +
+ +
+

Add output

+
+
+ + +
+
+ + +
+
+
+
+
+ + +
+
+ + +
+
+ + +
+ + +
+ +
+

Fixtures

+ + + +
IdNameProfileOutputStart
+ +
+ +
+

Add fixture

+ +
+
+ + +
+
+ + +
+
+
+
+ + +
+
+ + +
+
+ + +
+
+ +
+ + + +
+ +
+

Play pattern

+
+
+ + +
+
+ + +
+
+ + +
+
+
+
+ + +
+
+ + +
+
+ + +
+ +

+ + + + +""" + + +def list_serial_ports(): + paths = [] + for pattern in ("/dev/ttyUSB*", "/dev/ttyACM*", "/dev/tty.usb*", "/dev/cu.usb*"): + try: + paths.extend(glob.glob(pattern)) + except Exception: + pass + seen = set() + out = [] + for p in sorted(paths): + if p not in seen: + seen.add(p) + out.append(p) + return out + + +def create_app(settings, outputs, player): + app = Microdot() + + @app.route("/") + async def index(request): + return Response(body=INDEX_HTML, headers={"Content-Type": "text/html; charset=utf-8"}) + + @app.route("/api/settings", methods=["GET"]) + async def get_settings(request): + return settings._as_dict() + + @app.route("/api/settings", methods=["PUT"]) + async def put_settings(request): + data = request.json + if not isinstance(data, dict): + return {"error": "JSON object required"}, 400 + settings.apply_dict(data) + outputs.configure(settings.get("outputs") or []) + return settings._as_dict() + + @app.route("/api/serial-ports") + async def serial_ports(request): + return list_serial_ports() + + @app.route("/api/patterns") + async def list_patterns(request): + return player.pattern_ids() + + @app.route("/api/profiles") + async def profiles(request): + return { + "profiles": PROFILE_CHANNELS, + "roles": list(ALLOWED_ROLES), + } + + @app.route("/api/channels", methods=["POST"]) + async def set_channels(request): + data = request.json or {} + r = int(data.get("r") or 0) & 0xFF + g = int(data.get("g") or 0) & 0xFF + b = int(data.get("b") or 0) & 0xFF + dimmer = data.get("dimmer") + if dimmer is None: + dimmer = 255 + dimmer = int(dimmer) & 0xFF + outputs.set_rgb(r, g, b, dimmer) + return {"ok": True, "r": r, "g": g, "b": b, "dimmer": dimmer} + + @app.route("/api/blackout", methods=["POST"]) + async def blackout(request): + player.generator = None + player.preset = None + outputs.blackout() + return {"ok": True} + + @app.route("/api/identify", methods=["POST"]) + async def identify(request): + data = request.json or {} + fid = data.get("fixture_id") + if not fid: + return {"error": "fixture_id required"}, 400 + if not player.identify(str(fid)): + return {"error": "fixture not found"}, 404 + return {"ok": True} + + @app.route("/api/play", methods=["POST"]) + async def play(request): + data = request.json or {} + if not isinstance(data, dict): + return {"error": "JSON object required"}, 400 + preset = Preset(data) + if data.get("pattern"): + preset.p = str(data.get("pattern")) + targets = None + fid = data.get("fixture_id") + if fid: + targets = [str(fid)] + player.select(preset, targets=targets, preset_id=None) + return {"ok": True, "pattern": preset.p} + + @app.post("/patterns/upload") + async def upload_pattern(request): + raw_name = request.args.get("name") + reload_raw = request.args.get("reload", "1") + reload_patterns = str(reload_raw).strip().lower() not in ("0", "false", "no", "off") + + if not isinstance(raw_name, str) or not raw_name.strip(): + return ( + json.dumps({"error": "name is required"}), + 400, + {"Content-Type": "application/json"}, + ) + body = request.body + if not isinstance(body, (bytes, bytearray)) or not body: + return ( + json.dumps({"error": "code is required"}), + 400, + {"Content-Type": "application/json"}, + ) + try: + code = body.decode("utf-8") + except UnicodeError: + return ( + json.dumps({"error": "body must be utf-8 text"}), + 400, + {"Content-Type": "application/json"}, + ) + if not code.strip(): + return ( + json.dumps({"error": "code is required"}), + 400, + {"Content-Type": "application/json"}, + ) + + name = raw_name.strip() + if not name.endswith(".py"): + name += ".py" + if not safe_pattern_filename(name) or name in ("__init__.py", "main.py"): + return ( + json.dumps({"error": "invalid pattern filename"}), + 400, + {"Content-Type": "application/json"}, + ) + + try: + os.mkdir("patterns") + except OSError: + pass + + path = os.path.join("patterns", name) + try: + with open(path, "w") as f: + f.write(code) + if reload_patterns: + player.reload_patterns() + except OSError as e: + print("patterns/upload failed:", e) + return ( + json.dumps({"error": str(e)}), + 500, + {"Content-Type": "application/json"}, + ) + + return ( + json.dumps( + { + "message": "pattern uploaded", + "name": name, + "reloaded": reload_patterns, + } + ), + 201, + {"Content-Type": "application/json"}, + ) + + @app.route("/ws") + @with_websocket + async def ws_handler(request, ws): + try: + while True: + data = await ws.receive() + if not data: + break + process_data(data, settings, outputs, player=player) + except WebSocketError as e: + print("WS client disconnected:", e) + except OSError as e: + print("WS client dropped:", e) + + return app diff --git a/src/main.py b/src/main.py new file mode 100644 index 0000000..dc529aa --- /dev/null +++ b/src/main.py @@ -0,0 +1,53 @@ +# DMX gateway: controller WS in → Art-Net + serial out. Web UI on :8080. + +import asyncio +import sys + +from settings import Settings +from outputs import OutputManager +from player import PatternPlayer +from http_app import create_app + +WEB_HOST = "0.0.0.0" +WEB_PORT = 8080 +TICK_S = 0.025 # ~40 Hz + + +async def output_tick(outputs, player): + while True: + try: + player.tick() + outputs.tick() + except Exception as e: + print("tick error:", e) + await asyncio.sleep(TICK_S) + + +async def main(): + settings = Settings() + outputs = OutputManager() + outputs.configure(settings.get("outputs") or []) + player = PatternPlayer(settings, outputs) + + app = create_app(settings, outputs, player) + print("dmx-gateway", settings.get("name"), "http://%s:%s/" % (WEB_HOST, WEB_PORT)) + print("outputs", len(settings.get("outputs") or [])) + print("fixtures", len(settings.get("fixtures") or [])) + + tick_task = asyncio.create_task(output_tick(outputs, player)) + try: + await app.start_server(host=WEB_HOST, port=WEB_PORT, debug=False) + finally: + tick_task.cancel() + try: + await tick_task + except asyncio.CancelledError: + pass + outputs.close() + + +if __name__ == "__main__": + try: + asyncio.run(main()) + except KeyboardInterrupt: + print("stopped", file=sys.stderr) diff --git a/src/outputs.py b/src/outputs.py new file mode 100644 index 0000000..4cf45f3 --- /dev/null +++ b/src/outputs.py @@ -0,0 +1,215 @@ +# Fan-out per-output 512-channel universes to Art-Net and serial. + +import socket + +from artnet import PORT, as_channels, build_artdmx +from serial_dmx import SerialDMX + + +class OutputManager: + """One 512-slot buffer per output id, sent ~40 Hz when enabled.""" + + def __init__(self): + self._buffers = {} + self.frame = bytearray(513) + self._outputs = [] + self._serial = {} + self._sock = None + self._sequences = {} + self._ensure_sock() + + def _ensure_sock(self): + if self._sock is not None: + return + sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + try: + sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + except OSError: + pass + sock.bind(("0.0.0.0", 0)) + self._sock = sock + + def buffer(self, output_id): + oid = str(output_id or "") + if oid not in self._buffers: + self._buffers[oid] = bytearray(512) + return self._buffers[oid] + + def close(self): + for sid, ser in list(self._serial.items()): + try: + ser.close() + except Exception: + pass + self._serial.clear() + if self._sock is not None: + try: + self._sock.close() + except Exception: + pass + self._sock = None + + def configure(self, outputs): + if not isinstance(outputs, list): + outputs = [] + self._outputs = list(outputs) + keep = set() + for out in self._outputs: + oid = out.get("id") + if not oid: + continue + keep.add(oid) + self.buffer(oid) + + for oid in list(self._buffers.keys()): + if oid and oid not in keep: + del self._buffers[oid] + + want = {} + for out in self._outputs: + if out.get("type") != "serial" or not out.get("enabled"): + continue + key = (out["id"], out.get("path"), int(out.get("baud") or 250000)) + want[out["id"]] = key + + for sid in list(self._serial.keys()): + if sid not in want: + try: + self._serial[sid].close() + except Exception: + pass + del self._serial[sid] + + for sid, key in want.items(): + existing = self._serial.get(sid) + if existing is not None and ( + existing.path == key[1] and existing.baud == key[2] + ): + continue + if existing is not None: + try: + existing.close() + except Exception: + pass + self._serial[sid] = SerialDMX(key[1], baud=key[2]) + + def set_channels(self, data, output_id=None): + raw = as_channels(data) + n = len(raw) + if n > 512: + n = 512 + if output_id is None: + targets = list(self._buffers.values()) + if not targets: + targets = [self.buffer("")] + else: + targets = [self.buffer(output_id)] + for buf in targets: + buf[:n] = raw[:n] + + def set_rgb(self, r, g, b, dimmer=255, output_id=None): + if output_id is None: + targets = list(self._buffers.values()) + if not targets: + targets = [self.buffer("")] + else: + targets = [self.buffer(output_id)] + for buf in targets: + buf[0] = int(r) & 0xFF + buf[1] = int(g) & 0xFF + buf[2] = int(b) & 0xFF + buf[3] = int(dimmer) & 0xFF + + def blackout(self, output_id=None): + if output_id is None: + targets = list(self._buffers.values()) + if not targets: + targets = [self.buffer("")] + else: + targets = [self.buffer(output_id)] + for buf in targets: + for i in range(512): + buf[i] = 0 + + def write_fixture(self, fixture, role_values): + if not isinstance(fixture, dict) or not isinstance(role_values, dict): + return + oid = fixture.get("output_id") + if not oid: + return + buf = self.buffer(oid) + try: + start = int(fixture.get("start_channel") or 1) - 1 + except (TypeError, ValueError): + start = 0 + if start < 0: + start = 0 + channels = fixture.get("channels") or [] + for i, ch in enumerate(channels): + if not isinstance(ch, dict): + continue + role = ch.get("role") + if role not in role_values: + continue + idx = start + i + if idx < 0 or idx >= 512: + continue + try: + buf[idx] = int(role_values[role]) & 0xFF + except (TypeError, ValueError): + pass + + def _next_sequence(self, oid): + seq = self._sequences.get(oid, 1) + self._sequences[oid] = 1 if seq >= 255 else seq + 1 + return seq + + def _universe_parts(self, universe): + u = int(universe or 0) & 0x7FFF + net = (u >> 8) & 0x7F + subnet = (u >> 4) & 0x0F + uni = u & 0x0F + return uni, subnet, net + + def _send_artnet(self, out): + self._ensure_sock() + uni, subnet, net = self._universe_parts(out.get("universe")) + seq = self._next_sequence(out["id"]) + channels = self.buffer(out["id"]) + pkt = build_artdmx( + channels, + universe=uni, + subnet=subnet, + net=net, + sequence=seq, + ) + host = out.get("host") or "127.0.0.1" + port = int(out.get("port") or PORT) + try: + self._sock.sendto(pkt, (host, port)) + except OSError as e: + print("artnet send failed", host, port, e) + + def _send_serial(self, out): + ser = self._serial.get(out["id"]) + if ser is None: + return + channels = self.buffer(out["id"]) + self.frame[0] = 0 + self.frame[1:513] = channels + ser.send(self.frame) + + def tick(self): + for out in self._outputs: + if not out.get("enabled"): + continue + if out.get("type") == "serial": + self._send_serial(out) + else: + self._send_artnet(out) + + @property + def channels(self): + if self._buffers: + return next(iter(self._buffers.values())) + return self.buffer("") diff --git a/src/patterns/__init__.py b/src/patterns/__init__.py new file mode 100644 index 0000000..b73de97 --- /dev/null +++ b/src/patterns/__init__.py @@ -0,0 +1 @@ +# Seed / uploaded DMX patterns. Each module exposes a class with run(preset, write_roles). diff --git a/src/patterns/blink.py b/src/patterns/blink.py new file mode 100644 index 0000000..77eabc7 --- /dev/null +++ b/src/patterns/blink.py @@ -0,0 +1,40 @@ +import time + + +class Blink: + id = "blink" + + def run(self, preset, write_roles): + colour_index = 0 + state = True + # Force first paint on the initial tick. + last_update = 0.0 + while True: + delay_ms = max(1, int(preset.d)) + now = time.time() * 1000.0 + if now - last_update >= delay_ms: + colours = preset.c if preset.c else [(255, 255, 255)] + if state: + r, g, b = colours[colour_index % len(colours)] + write_roles( + { + "dimmer": int(preset.b) & 0xFF, + "red": int(r) & 0xFF, + "green": int(g) & 0xFF, + "blue": int(b) & 0xFF, + } + ) + colour_index += 1 + else: + bg = preset.background_or(default=(0, 0, 0)) + write_roles( + { + "dimmer": 0, + "red": int(bg[0]) & 0xFF, + "green": int(bg[1]) & 0xFF, + "blue": int(bg[2]) & 0xFF, + } + ) + state = not state + last_update = now + yield diff --git a/src/patterns/pulse.py b/src/patterns/pulse.py new file mode 100644 index 0000000..c98b655 --- /dev/null +++ b/src/patterns/pulse.py @@ -0,0 +1,29 @@ +import math +import time + + +class Pulse: + id = "pulse" + + def run(self, preset, write_roles): + start = time.time() + while True: + colours = preset.c if preset.c else [(255, 255, 255)] + r, g, b = colours[0] + # Period from delay (ms); n1 scales speed (0 = normal). + period_ms = max(50, int(preset.d)) + speed = 1.0 + (int(preset.n1) / 100.0) + t = (time.time() - start) * 1000.0 * speed + phase = (t % period_ms) / float(period_ms) + # 0..1..0 triangle via sine + level = (math.sin(phase * math.pi * 2.0) + 1.0) * 0.5 + dimmer = int(int(preset.b) * level) & 0xFF + write_roles( + { + "dimmer": dimmer, + "red": int(r) & 0xFF, + "green": int(g) & 0xFF, + "blue": int(b) & 0xFF, + } + ) + yield diff --git a/src/patterns/solid.py b/src/patterns/solid.py new file mode 100644 index 0000000..ae8b079 --- /dev/null +++ b/src/patterns/solid.py @@ -0,0 +1,16 @@ +class Solid: + id = "solid" + + def run(self, preset, write_roles): + while True: + colours = preset.c if preset.c else [(255, 255, 255)] + r, g, b = colours[0] + write_roles( + { + "dimmer": int(preset.b) & 0xFF, + "red": int(r) & 0xFF, + "green": int(g) & 0xFF, + "blue": int(b) & 0xFF, + } + ) + yield diff --git a/src/player.py b/src/player.py new file mode 100644 index 0000000..2908e8b --- /dev/null +++ b/src/player.py @@ -0,0 +1,161 @@ +# Pattern registry + led-driver-style generator tick for DMX fixtures. + +import importlib.util +import os +import sys + + +def _safe_pattern_filename(name): + if not isinstance(name, str): + return False + if not name.endswith(".py"): + return False + if "/" in name or "\\" in name or ".." in name: + return False + return True + + +class PatternPlayer: + def __init__(self, settings, outputs): + self.settings = settings + self.outputs = outputs + self.patterns = {} + self.preset = None + self.preset_id = None + self.targets = None # None = all fixtures; else set/list of fixture ids + self.generator = None + self.reload_patterns() + + def pattern_ids(self): + return sorted(self.patterns.keys()) + + def _pattern_dirs(self): + here = os.path.dirname(__file__) + dirs = [os.path.join(here, "patterns")] + cwd_patterns = os.path.join(os.getcwd(), "patterns") + if cwd_patterns not in dirs: + dirs.append(cwd_patterns) + return dirs + + def _load_file(self, path, basename, loaded): + module_name = "dmx_pattern_%s" % basename + try: + if module_name in sys.modules: + del sys.modules[module_name] + spec = importlib.util.spec_from_file_location(module_name, path) + if spec is None or spec.loader is None: + return + module = importlib.util.module_from_spec(spec) + sys.modules[module_name] = module + spec.loader.exec_module(module) + except Exception as e: + print("Pattern import failed:", path, e) + return + + pattern_class = None + for attr_name in dir(module): + attr = getattr(module, attr_name) + if isinstance(attr, type) and hasattr(attr, "run") and attr_name[:1].isupper(): + pattern_class = attr + break + if pattern_class is None: + return + pid = getattr(pattern_class, "id", None) or basename + try: + loaded[str(pid)] = pattern_class + except Exception as e: + print("Pattern register failed:", path, e) + + def reload_patterns(self): + loaded = {} + # Seed first, then cwd uploads overwrite on id conflict. + for directory in self._pattern_dirs(): + try: + names = os.listdir(directory) + except OSError: + continue + for filename in sorted(names): + if not filename.endswith(".py") or filename in ("__init__.py", "main.py"): + continue + path = os.path.join(directory, filename) + if not os.path.isfile(path): + continue + self._load_file(path, filename[:-3], loaded) + self.patterns = loaded + # Rebind active generator if still available. + if self.preset is not None and self.generator is not None: + self._start_generator() + print("patterns loaded", sorted(self.patterns.keys())) + + def write_roles(self, roles): + fixtures = self.settings.get("fixtures") or [] + for fix in fixtures: + if not isinstance(fix, dict): + continue + fid = fix.get("id") + if self.targets is not None: + names = self.targets + if fid not in names and fix.get("name") not in names: + continue + self.outputs.write_fixture(fix, roles) + + def _start_generator(self): + self.generator = None + if self.preset is None: + return + pattern_id = self.preset.p + if pattern_id in ("off", ""): + self.outputs.blackout() + return + cls = self.patterns.get(pattern_id) + if cls is None: + print("unknown pattern", pattern_id) + return + try: + inst = cls() + self.generator = inst.run(self.preset, self.write_roles) + except Exception as e: + print("pattern start failed", pattern_id, e) + self.generator = None + + def select(self, preset, targets=None, preset_id=None): + self.preset = preset + self.preset_id = preset_id + if targets is None: + self.targets = None + else: + self.targets = list(targets) + self._start_generator() + + def edit_active(self, data, preset_id=None): + if self.preset is None: + return False + if preset_id is not None and self.preset_id is not None and str(preset_id) != str(self.preset_id): + return False + return self.preset.edit(data) + + def tick(self): + if self.generator is None: + return + try: + next(self.generator) + except StopIteration: + self.generator = None + except Exception as e: + print("pattern tick error:", e) + self.generator = None + + def identify(self, fixture_id): + fixtures = self.settings.get("fixtures") or [] + for fix in fixtures: + if fix.get("id") == fixture_id or fix.get("name") == fixture_id: + self.outputs.write_fixture( + fix, + {"dimmer": 255, "red": 255, "green": 255, "blue": 255, "pan": 128, "tilt": 128}, + ) + return True + return False + + +# Re-export for upload route validation +safe_pattern_filename = _safe_pattern_filename diff --git a/src/preset.py b/src/preset.py new file mode 100644 index 0000000..bf00f70 --- /dev/null +++ b/src/preset.py @@ -0,0 +1,176 @@ +def _parse_colour(value): + if isinstance(value, (list, tuple)) and len(value) >= 3: + try: + return ( + max(0, min(255, int(value[0]))), + max(0, min(255, int(value[1]))), + max(0, min(255, int(value[2]))), + ) + except (TypeError, ValueError): + return None + if not isinstance(value, str): + return None + s = value.strip() + if s.startswith("#"): + s = s[1:] + if len(s) == 3: + s = s[0] * 2 + s[1] * 2 + s[2] * 2 + if len(s) != 6: + return None + try: + return (int(s[0:2], 16), int(s[2:4], 16), int(s[4:6], 16)) + except ValueError: + return None + + +class Preset: + def __init__(self, data): + # Set default values for all preset attributes + self.p = "off" + self.d = 100 + self.b = 127 + self.c = [(255, 255, 255)] + self.a = True + self.n1 = 0 + self.n2 = 0 + self.n3 = 0 + self.n4 = 0 + self.n5 = 0 + self.n6 = 0 + self.bg = (0, 0, 0) + + # Override defaults with provided data + self.edit(data) + + def edit(self, data=None): + if not data: + return False + aliases = { + "pattern": "p", + "colors": "c", + "delay": "d", + "brightness": "b", + "auto": "a", + "background": "bg", + "mode": "n6", + } + int_fields = {"d", "b", "n1", "n2", "n3", "n4", "n5", "n6"} + allowed_fields = {"p", "c", "d", "b", "a", "bg", "n1", "n2", "n3", "n4", "n5", "n6"} + for key, value in data.items(): + if key == "reverse": + try: + if isinstance(value, bool): + self.n5 = 1 if value else 0 + elif isinstance(value, (int, float)): + self.n5 = 1 if int(value) else 0 + elif isinstance(value, str): + lowered = value.lower() + self.n5 = 1 if lowered in ("true", "1", "yes", "on") else 0 + except (TypeError, ValueError): + pass + continue + key = aliases.get(key, key) + if key not in allowed_fields: + continue + if key in int_fields: + try: + parsed = int(value) + if key == "b": + parsed = max(0, min(255, parsed)) + elif key in ("d", "n1", "n2", "n3", "n4", "n5", "n6"): + parsed = max(0, parsed) + setattr(self, key, parsed) + except (TypeError, ValueError): + continue + elif key == "a": + if isinstance(value, bool): + self.a = value + elif isinstance(value, int): + self.a = bool(value) + elif isinstance(value, str): + lowered = value.lower() + if lowered in ("true", "1", "yes", "on"): + self.a = True + elif lowered in ("false", "0", "no", "off"): + self.a = False + elif key == "c": + if isinstance(value, (list, tuple)): + colours = [] + for item in value: + rgb = _parse_colour(item) + if rgb is not None: + colours.append(rgb) + if colours: + self.c = colours + elif key == "bg": + rgb = _parse_colour(value) + if rgb is not None: + self.bg = rgb + else: + setattr(self, key, value) + return True + + @property + def pattern(self): + return self.p + + @pattern.setter + def pattern(self, value): + self.p = value + + @property + def delay(self): + return self.d + + @delay.setter + def delay(self, value): + self.d = value + + @property + def brightness(self): + return self.b + + @brightness.setter + def brightness(self, value): + self.b = value + + @property + def colors(self): + return self.c + + @colors.setter + def colors(self, value): + self.c = value + + @property + def auto(self): + return self.a + + @auto.setter + def auto(self, value): + self.a = value + + def background_or(self, colors=None, default=(0, 0, 0)): + bg = getattr(self, "bg", None) + if isinstance(bg, (list, tuple)) and len(bg) == 3: + try: + return tuple(max(0, min(255, int(x))) for x in bg) + except (TypeError, ValueError): + return default + return default + + def to_dict(self): + return { + "p": self.p, + "d": self.d, + "b": self.b, + "c": self.c, + "a": self.a, + "bg": self.bg, + "n1": self.n1, + "n2": self.n2, + "n3": self.n3, + "n4": self.n4, + "n5": self.n5, + "n6": self.n6, + } diff --git a/src/settings.py b/src/settings.py new file mode 100644 index 0000000..b373bc0 --- /dev/null +++ b/src/settings.py @@ -0,0 +1,215 @@ +import json + +PROFILE_CHANNELS = { + "parcan": [ + {"role": "dimmer", "label": "Dimmer"}, + {"role": "red", "label": "Red"}, + {"role": "green", "label": "Green"}, + {"role": "blue", "label": "Blue"}, + ], + "mover": [ + {"role": "pan", "label": "Pan"}, + {"role": "tilt", "label": "Tilt"}, + {"role": "dimmer", "label": "Dimmer"}, + {"role": "red", "label": "Red"}, + {"role": "green", "label": "Green"}, + {"role": "blue", "label": "Blue"}, + ], +} + +ALLOWED_ROLES = ("dimmer", "red", "green", "blue", "pan", "tilt") + + +class Settings(dict): + SETTINGS_FILE = "/settings.json" + + def __init__(self): + super().__init__() + self.load() + + def set_defaults(self): + self["name"] = "dmx-gateway" + self["outputs"] = [] + self["fixtures"] = [] + + def _normalize_output(self, raw): + if not isinstance(raw, dict): + return None + oid = raw.get("id") + if not oid: + return None + otype = raw.get("type") or "artnet" + enabled = raw.get("enabled") + if enabled is None: + enabled = True + out = { + "id": str(oid), + "type": str(otype), + "enabled": bool(enabled), + } + if out["type"] == "serial": + out["path"] = str(raw.get("path") or "/dev/ttyUSB0") + try: + out["baud"] = int(raw.get("baud") or 250000) + except (TypeError, ValueError): + out["baud"] = 250000 + else: + out["type"] = "artnet" + out["host"] = str(raw.get("host") or "127.0.0.1") + try: + out["port"] = int(raw.get("port") or 6454) + except (TypeError, ValueError): + out["port"] = 6454 + try: + out["universe"] = int(raw.get("universe") or 0) & 0x7FFF + except (TypeError, ValueError): + out["universe"] = 0 + return out + + def _normalize_outputs(self, raw): + if not isinstance(raw, list): + return [] + outs = [] + seen = set() + for item in raw: + out = self._normalize_output(item) + if out is None or out["id"] in seen: + continue + seen.add(out["id"]) + outs.append(out) + return outs + + def _normalize_channels(self, raw, profile): + if isinstance(raw, list) and raw: + channels = [] + for item in raw: + if not isinstance(item, dict): + continue + role = str(item.get("role") or "").strip().lower() + if role not in ALLOWED_ROLES: + continue + label = item.get("label") or role.capitalize() + channels.append({"role": role, "label": str(label)}) + if channels: + return channels + return [dict(c) for c in PROFILE_CHANNELS.get(profile, PROFILE_CHANNELS["parcan"])] + + def _normalize_fixture(self, raw, output_ids): + if not isinstance(raw, dict): + return None + fid = raw.get("id") + if not fid: + return None + profile = str(raw.get("profile") or "parcan").strip().lower() + if profile not in PROFILE_CHANNELS: + profile = "parcan" + output_id = str(raw.get("output_id") or "") + try: + start = int(raw.get("start_channel") or 1) + except (TypeError, ValueError): + start = 1 + if start < 1: + start = 1 + if start > 512: + start = 512 + channels = self._normalize_channels(raw.get("channels"), profile) + if start - 1 + len(channels) > 512: + return None + return { + "id": str(fid), + "name": str(raw.get("name") or fid), + "output_id": output_id, + "start_channel": start, + "profile": profile, + "channels": channels, + } + + def _normalize_fixtures(self, raw, outputs=None): + if not isinstance(raw, list): + return [] + if outputs is None: + outputs = self.get("outputs") or [] + output_ids = {o["id"] for o in outputs if isinstance(o, dict) and o.get("id")} + fixtures = [] + seen = set() + used = {} + for item in raw: + fix = self._normalize_fixture(item, output_ids) + if fix is None or fix["id"] in seen: + continue + oid = fix["output_id"] + start = fix["start_channel"] - 1 + span = set(range(start, start + len(fix["channels"]))) + occupied = used.get(oid) or set() + if oid and span & occupied: + print("fixture overlap rejected", fix["id"], "on", oid) + continue + if oid: + used[oid] = occupied | span + seen.add(fix["id"]) + fixtures.append(fix) + return fixtures + + def _as_dict(self): + outputs = self._normalize_outputs(self.get("outputs") or []) + return { + "name": self.get("name") or "dmx-gateway", + "outputs": outputs, + "fixtures": self._normalize_fixtures(self.get("fixtures") or [], outputs), + } + + def save(self): + try: + raw = json.dumps(self._as_dict()) + except Exception as e: + print("Error saving settings:", e) + return + err = None + for path in (self.SETTINGS_FILE, "settings.json"): + try: + f = open(path, "w") + f.write(raw) + f.close() + self.SETTINGS_FILE = path + return + except Exception as e: + err = e + print("Error saving settings:", err) + + def load(self): + self.set_defaults() + for path in (self.SETTINGS_FILE, "settings.json"): + try: + f = open(path, "r") + loaded = json.load(f) + f.close() + except Exception: + continue + if not isinstance(loaded, dict) or not loaded: + continue + self["name"] = loaded.get("name") or "dmx-gateway" + self["outputs"] = self._normalize_outputs(loaded.get("outputs") or []) + self["fixtures"] = self._normalize_fixtures( + loaded.get("fixtures") or [], self["outputs"] + ) + self.SETTINGS_FILE = path + return + print("Error loading settings") + self.save() + + def apply_dict(self, data): + if not isinstance(data, dict): + return + if "name" in data and data["name"]: + self["name"] = str(data["name"]) + if "outputs" in data: + self["outputs"] = self._normalize_outputs(data["outputs"]) + if "fixtures" in data: + self["fixtures"] = self._normalize_fixtures( + data["fixtures"], self.get("outputs") or [] + ) + elif "outputs" in data: + self["fixtures"] = self._normalize_fixtures( + self.get("fixtures") or [], self.get("outputs") or [] + ) + self.save() diff --git a/src/wifi.py b/src/wifi.py new file mode 100644 index 0000000..ea728ec --- /dev/null +++ b/src/wifi.py @@ -0,0 +1,54 @@ +# SoftAP helper for MicroPython ESP32. No-op on desktop CPython. + +from time import sleep + +try: + import network +except ImportError: + network = None + + +def ap(ssid, password=""): + """Bring up SoftAP. Open network if password is empty or shorter than 8 chars. + + On CPython (no ``network`` module) prints a skip message and returns None. + """ + if network is None: + print("ap skip (desktop): SoftAP not available; bind Art-Net on 0.0.0.0") + return None + + sta = network.WLAN(network.STA_IF) + try: + if sta.active(): + try: + sta.disconnect() + except OSError: + pass + sta.active(False) + except OSError: + pass + + wlan = network.WLAN(network.AP_IF) + wlan.active(True) + cfg = {"essid": ssid} + if password and len(password) >= 8: + cfg["password"] = password + try: + cfg["authmode"] = network.AUTH_WPA_WPA2_PSK + except AttributeError: + pass + else: + try: + cfg["authmode"] = network.AUTH_OPEN + except AttributeError: + pass + wlan.config(**cfg) + + n = 0 + while not wlan.active() and n < 50: + sleep(0.1) + n += 1 + + ip = wlan.ifconfig()[0] + print("ap", ssid, ip, wlan.ifconfig()) + return wlan diff --git a/tests/artnet_dmx.py b/tests/artnet_dmx.py new file mode 100644 index 0000000..9bc7c07 --- /dev/null +++ b/tests/artnet_dmx.py @@ -0,0 +1,250 @@ +#!/usr/bin/env python3 +"""Desktop tests for Art-Net, fixtures, patterns, and upload. + +Run from dmx-driver repo root:: + + PYTHONPATH=src:lib python3 tests/artnet_dmx.py +""" + +import os +import sys +import socket + + +def _bootstrap_import_path(): + try: + here = __file__.rsplit("/", 1)[0] + except NameError: + here = "." + parent = here.rsplit("/", 1)[0] if "/" in here else ".." + for p in (parent + "/lib", parent + "/src", "lib", "src", ".", ".."): + if p and p not in sys.path: + sys.path.insert(0, p) + + +_bootstrap_import_path() + +from artnet import build_artdmx, parse # noqa: E402 +from serial_dmx import SerialDMX # noqa: E402 +from outputs import OutputManager # noqa: E402 +from controller import process_data # noqa: E402 +from settings import Settings # noqa: E402 +from preset import Preset # noqa: E402 +from player import PatternPlayer # noqa: E402 + + +def _assert_eq(label, got, expect): + if got != expect: + raise AssertionError("%s: got %r expected %r" % (label, got, expect)) + + +def test_build_artdmx(): + channels = bytearray(512) + channels[0] = 10 + channels[1] = 20 + channels[511] = 99 + pkt = build_artdmx(channels, universe=0, sequence=1) + kind = parse(pkt) + _assert_eq("kind", kind[0], "dmx") + _assert_eq("ch1", kind[3][0], 10) + _assert_eq("ch2", kind[3][1], 20) + _assert_eq("ch512", kind[3][511], 99) + print("PASS build_artdmx") + + +def test_artnet_send_loopback(): + recv = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + recv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + recv.bind(("127.0.0.1", 0)) + host, port = recv.getsockname() + recv.settimeout(1.0) + + outs = OutputManager() + outs.configure( + [ + { + "id": "loop", + "type": "artnet", + "enabled": True, + "host": host, + "port": port, + "universe": 0, + } + ] + ) + outs.set_rgb(1, 2, 3, 4, output_id="loop") + outs.tick() + + data, _addr = recv.recvfrom(2048) + recv.close() + outs.close() + + kind = parse(data) + _assert_eq("kind", kind[0], "dmx") + _assert_eq("ch1", kind[3][0], 1) + _assert_eq("ch2", kind[3][1], 2) + _assert_eq("ch3", kind[3][2], 3) + _assert_eq("ch4", kind[3][3], 4) + print("PASS artnet_send_loopback") + + +def test_fixture_patch(): + settings = Settings() + settings["outputs"] = [ + { + "id": "a1", + "type": "artnet", + "enabled": True, + "host": "127.0.0.1", + "port": 6454, + "universe": 0, + } + ] + settings["fixtures"] = settings._normalize_fixtures( + [ + { + "id": "f1", + "name": "Par 1", + "output_id": "a1", + "start_channel": 5, + "profile": "parcan", + } + ], + settings["outputs"], + ) + outs = OutputManager() + outs.configure(settings["outputs"]) + fix = settings["fixtures"][0] + outs.write_fixture(fix, {"dimmer": 200, "red": 10, "green": 20, "blue": 30}) + buf = outs.buffer("a1") + # start_channel 5 → index 4 + _assert_eq("dimmer", buf[4], 200) + _assert_eq("red", buf[5], 10) + _assert_eq("green", buf[6], 20) + _assert_eq("blue", buf[7], 30) + outs.close() + print("PASS fixture_patch") + + +def test_pattern_blink_and_select(): + settings = Settings() + settings["name"] = "dmx-gateway" + settings["outputs"] = [ + { + "id": "a1", + "type": "artnet", + "enabled": True, + "host": "127.0.0.1", + "port": 6454, + "universe": 0, + } + ] + settings["fixtures"] = settings._normalize_fixtures( + [ + { + "id": "f1", + "name": "Par 1", + "output_id": "a1", + "start_channel": 1, + "profile": "parcan", + } + ], + settings["outputs"], + ) + outs = OutputManager() + outs.configure(settings["outputs"]) + player = PatternPlayer(settings, outs) + _assert_eq("has_blink", "blink" in player.patterns, True) + + process_data( + { + "v": "1", + "presets": { + "wash": { + "pattern": "solid", + "colors": ["#FF0000"], + "brightness": 200, + } + }, + "select": {"f1": ["wash"]}, + }, + settings, + outs, + player=player, + ) + player.tick() + buf = outs.buffer("a1") + _assert_eq("dimmer", buf[0], 200) + _assert_eq("red", buf[1], 255) + _assert_eq("green", buf[2], 0) + _assert_eq("blue", buf[3], 0) + + preset = Preset({"pattern": "blink", "colors": ["#00FF00"], "brightness": 255, "delay": 500}) + player.select(preset, targets=["f1"], preset_id="b") + player.tick() + buf = outs.buffer("a1") + _assert_eq("blink_green", buf[2], 255) + outs.close() + print("PASS pattern_blink_and_select") + + +def test_pattern_upload(tmp_path=None): + settings = Settings() + settings["outputs"] = [] + settings["fixtures"] = [] + outs = OutputManager() + player = PatternPlayer(settings, outs) + code = ( + "class UploadProbe:\\n" + " id = 'upload_probe'\\n" + " def run(self, preset, write_roles):\\n" + " while True:\\n" + " write_roles({'dimmer': 1, 'red': 2, 'green': 3, 'blue': 4})\\n" + " yield\\n" + ) + # Write via the same path upload uses + try: + os.mkdir("patterns") + except OSError: + pass + path = os.path.join("patterns", "upload_probe.py") + with open(path, "w") as f: + f.write(code.replace("\\n", "\n")) + try: + player.reload_patterns() + _assert_eq("uploaded", "upload_probe" in player.patterns, True) + finally: + try: + os.remove(path) + except OSError: + pass + outs.close() + print("PASS pattern_upload") + + +def test_serial_frame_layout(): + outs = OutputManager() + outs.set_rgb(10, 20, 30, 40) + outs.frame[0] = 0 + outs.frame[1:513] = outs.channels + _assert_eq("start_code", outs.frame[0], 0) + _assert_eq("frame_ch1", outs.frame[1], 10) + ser = SerialDMX("/dev/null_does_not_exist_dmx_test", baud=250000) + _assert_eq("ser_closed", ser.ser is None, True) + ser.close() + outs.close() + print("PASS serial_frame_layout") + + +def main(): + test_build_artdmx() + test_artnet_send_loopback() + test_serial_frame_layout() + test_fixture_patch() + test_pattern_blink_and_select() + test_pattern_upload() + print("PASS") + + +if __name__ == "__main__": + main()