Compare commits
564 Commits
emmental-2
...
main
Author | SHA1 | Date |
---|---|---|
Anna Schumaker | c3818a2b18 | |
Anna Schumaker | 19c47be056 | |
Anna Schumaker | dbc60e1c5f | |
Anna Schumaker | 6779535cf1 | |
Anna Schumaker | 2ae5fd0969 | |
Anna Schumaker | b1490fd447 | |
Anna Schumaker | 4c5d3c78c0 | |
Anna Schumaker | 84a832389f | |
Anna Schumaker | 924f65fddd | |
Anna Schumaker | 14c153733d | |
Anna Schumaker | efe2611422 | |
Anna Schumaker | c49a23b046 | |
Anna Schumaker | a944af7f3e | |
Anna Schumaker | c5867badae | |
Anna Schumaker | e85bdcc7f4 | |
Anna Schumaker | c7dca6164e | |
Anna Schumaker | eada937b7a | |
Anna Schumaker | d373c33283 | |
Anna Schumaker | 1db187dba5 | |
Anna Schumaker | 0d100ec752 | |
Anna Schumaker | c4e827bc5a | |
Anna Schumaker | a4e0968ef4 | |
Anna Schumaker | 58a1df1d1d | |
Anna Schumaker | 3c25dc2c7f | |
Anna Schumaker | c37ae94a5d | |
Anna Schumaker | e6a219017d | |
Anna Schumaker | 3c15515faf | |
Anna Schumaker | 6c6ebf3676 | |
Anna Schumaker | ad8fd70f9a | |
Anna Schumaker | 8c316d0126 | |
Anna Schumaker | 3f153e1423 | |
Anna Schumaker | a08273535c | |
Anna Schumaker | ae1c611959 | |
Anna Schumaker | e73b6c09e7 | |
Anna Schumaker | b02fd609f7 | |
Anna Schumaker | 3241830c8e | |
Anna Schumaker | 97659f212d | |
Anna Schumaker | d22a9b23a1 | |
Anna Schumaker | 29693dcf84 | |
Anna Schumaker | bee48deac6 | |
Anna Schumaker | 5e096fa704 | |
Anna Schumaker | 6ebf29a632 | |
Anna Schumaker | a4f30d87e6 | |
Anna Schumaker | 51b290e1f0 | |
Anna Schumaker | fa203a72dd | |
Anna Schumaker | 3b8fb8531e | |
Anna Schumaker | 3e73ce0650 | |
Anna Schumaker | 17e4d85f1b | |
Anna Schumaker | 24675bf202 | |
Anna Schumaker | 072264a77c | |
Anna Schumaker | e7526f595f | |
Anna Schumaker | 7d2ec00da7 | |
Anna Schumaker | 70d7f5fa70 | |
Anna Schumaker | 2504f4b91d | |
Anna Schumaker | 7358183fef | |
Anna Schumaker | c195e68216 | |
Anna Schumaker | 1397e6e9e3 | |
Anna Schumaker | 717fdf39cd | |
Anna Schumaker | 9cf980d967 | |
Anna Schumaker | 87d8a2ae3a | |
Anna Schumaker | ddfd37130b | |
Anna Schumaker | 5011db344e | |
Anna Schumaker | 9f240bbc8b | |
Anna Schumaker | f6481f0182 | |
Anna Schumaker | 3d6350d7bd | |
Anna Schumaker | eb6b4d8ef4 | |
Anna Schumaker | f7349cd864 | |
Anna Schumaker | 30bcd30328 | |
Anna Schumaker | ef99951f74 | |
Anna Schumaker | 0fd391a9fd | |
Anna Schumaker | bc92e72265 | |
Anna Schumaker | 8dae0ed7bd | |
Anna Schumaker | 1707f87e45 | |
Anna Schumaker | 7e99fd1ba0 | |
Anna Schumaker | a8e7078308 | |
Anna Schumaker | 1d0813f217 | |
Anna Schumaker | 725619faf5 | |
Anna Schumaker | 6607e5b0ad | |
Anna Schumaker | 73019d8eb4 | |
Anna Schumaker | 6032e549a5 | |
Anna Schumaker | ba4907ec34 | |
Anna Schumaker | 06771ecab6 | |
Anna Schumaker | 17b2a82e20 | |
Anna Schumaker | c0c516fb70 | |
Anna Schumaker | 3cddde0986 | |
Anna Schumaker | 4f15bde850 | |
Anna Schumaker | 5ee86a9b5e | |
Anna Schumaker | 85c18fb5fe | |
Anna Schumaker | 67b508384c | |
Anna Schumaker | 929beb2a97 | |
Anna Schumaker | f400366210 | |
Anna Schumaker | 0c66b13209 | |
Anna Schumaker | e846c957a5 | |
Anna Schumaker | 37f81825b1 | |
Anna Schumaker | c375d2366a | |
Anna Schumaker | d807f8bd36 | |
Anna Schumaker | a13e481754 | |
Anna Schumaker | afb0ba5d68 | |
Anna Schumaker | 0307fae362 | |
Anna Schumaker | a6cd453c63 | |
Anna Schumaker | 7079076857 | |
Anna Schumaker | 8d72e1375f | |
Anna Schumaker | 87b92ffc90 | |
Anna Schumaker | bb4ca1e9c4 | |
Anna Schumaker | 087c378e59 | |
Anna Schumaker | 1f434358de | |
Anna Schumaker | 41cb325ad0 | |
Anna Schumaker | 0c1e5fcace | |
Anna Schumaker | 9cb927aabb | |
Anna Schumaker | 397c693aef | |
Anna Schumaker | eb162154b5 | |
Anna Schumaker | 2b5cdaa197 | |
Anna Schumaker | c5f9608c49 | |
Anna Schumaker | cae93cae11 | |
Anna Schumaker | 01a37dbbc1 | |
Anna Schumaker | 14c487c295 | |
Anna Schumaker | 57dd2c280e | |
Anna Schumaker | 59fb7d12f3 | |
Anna Schumaker | 93cdd9137a | |
Anna Schumaker | 45e95cc8c1 | |
Anna Schumaker | fa5cd55fce | |
Anna Schumaker | f307c92edb | |
Anna Schumaker | 8afd1a6240 | |
Anna Schumaker | 84fbd94aa1 | |
Anna Schumaker | 7155fa9db5 | |
Anna Schumaker | 0e40e6a4e8 | |
Anna Schumaker | deea9caa37 | |
Anna Schumaker | a626a1f3c4 | |
Anna Schumaker | dae588bfaf | |
Anna Schumaker | 03e5b9ad1b | |
Anna Schumaker | 5b0a0f54e4 | |
Anna Schumaker | dd9d6268ff | |
Anna Schumaker | a86ce6165d | |
Anna Schumaker | e624566919 | |
Anna Schumaker | b9a25ce5af | |
Anna Schumaker | bb9ecdbb5d | |
Anna Schumaker | 8b249b4b3e | |
Anna Schumaker | 55d7eb3d45 | |
Anna Schumaker | 8b1be777c1 | |
Anna Schumaker | 50474c7fd1 | |
Anna Schumaker | 6e4e83cb40 | |
Anna Schumaker | 78ea2904a1 | |
Anna Schumaker | a6f59d9378 | |
Anna Schumaker | ff9724a274 | |
Anna Schumaker | 911aeb84a1 | |
Anna Schumaker | ee1152bcc4 | |
Anna Schumaker | ed4a484a31 | |
Anna Schumaker | 83355f7e96 | |
Anna Schumaker | b326320156 | |
Anna Schumaker | 0c77e509c3 | |
Anna Schumaker | ed1d990e74 | |
Anna Schumaker | 2d19d78eb6 | |
Anna Schumaker | f1e18549ff | |
Anna Schumaker | ff1d772a05 | |
Anna Schumaker | a485a3806b | |
Anna Schumaker | 481c4856c7 | |
Anna Schumaker | 61dfc2a586 | |
Anna Schumaker | 97bf9d48db | |
Anna Schumaker | b3dcd3c0b9 | |
Anna Schumaker | 1ffc300eda | |
Anna Schumaker | bed518cd77 | |
Anna Schumaker | 915a59a46b | |
Anna Schumaker | 9edfc4a5b0 | |
Anna Schumaker | 999a3eb523 | |
Anna Schumaker | 2c2462c3d6 | |
Anna Schumaker | 0d27a09233 | |
Anna Schumaker | a687b564a9 | |
Anna Schumaker | 6bbc423193 | |
Anna Schumaker | cf056d6ec5 | |
Anna Schumaker | fd584e516a | |
Anna Schumaker | 820eda4c46 | |
Anna Schumaker | b0734a41d0 | |
Anna Schumaker | f5ef144419 | |
Anna Schumaker | 55486c20c3 | |
Anna Schumaker | 14bcef6e52 | |
Anna Schumaker | 6592b97cbd | |
Anna Schumaker | 2d18ce422e | |
Anna Schumaker | 58934d9b46 | |
Anna Schumaker | 45ddb22cc7 | |
Anna Schumaker | edaa275ba5 | |
Anna Schumaker | 298b58a54e | |
Anna Schumaker | 4ce571ebf8 | |
Anna Schumaker | fdfc12fbd2 | |
Anna Schumaker | 7d26d89405 | |
Anna Schumaker | 9a3d095081 | |
Anna Schumaker | 1aec9df0a8 | |
Anna Schumaker | eea763f133 | |
Anna Schumaker | 3cda4caa76 | |
Anna Schumaker | e0e7b556be | |
Anna Schumaker | 7920b3d5a8 | |
Anna Schumaker | e39d128488 | |
Anna Schumaker | 99eb4abee3 | |
Anna Schumaker | 0524085602 | |
Anna Schumaker | 36ca0b9818 | |
Anna Schumaker | 8e55de26d1 | |
Anna Schumaker | b4d8a7cfaa | |
Anna Schumaker | 6762916899 | |
Anna Schumaker | 99496ca8bf | |
Anna Schumaker | 85c42216ab | |
Anna Schumaker | 6eec4dbfc3 | |
Anna Schumaker | 1b9458c278 | |
Anna Schumaker | 11560d781e | |
Anna Schumaker | ff835832c8 | |
Anna Schumaker | 8a16b4e05f | |
Anna Schumaker | dc8ccff311 | |
Anna Schumaker | 08687882a3 | |
Anna Schumaker | 24cb87d298 | |
Anna Schumaker | afb599dcf4 | |
Anna Schumaker | 2c629c887c | |
Anna Schumaker | 4be92c7326 | |
Anna Schumaker | 1c0712e673 | |
Anna Schumaker | 0dcdcd4a68 | |
Anna Schumaker | 0de8089d59 | |
Anna Schumaker | 3ba46db064 | |
Anna Schumaker | f8494cf47b | |
Anna Schumaker | 0f2a5aee9d | |
Anna Schumaker | c396839316 | |
Anna Schumaker | 2f239bd94d | |
Anna Schumaker | 711c04cb29 | |
Anna Schumaker | d49b033b0d | |
Anna Schumaker | eb0b005c75 | |
Anna Schumaker | b316184bf1 | |
Anna Schumaker | 976f465cec | |
Anna Schumaker | 70799fa50f | |
Anna Schumaker | dcd63015b8 | |
Anna Schumaker | 0adb0d472b | |
Anna Schumaker | bf4fa68991 | |
Anna Schumaker | b25ca24dc3 | |
Anna Schumaker | 2542a6cbd7 | |
Anna Schumaker | 0584a2398a | |
Anna Schumaker | 673c6910e9 | |
Anna Schumaker | cdae9541e9 | |
Anna Schumaker | cd4caf7df8 | |
Anna Schumaker | 710f3fba80 | |
Anna Schumaker | 9d7763a730 | |
Anna Schumaker | 40c463da81 | |
Anna Schumaker | 5545cb106d | |
Anna Schumaker | 6131640e25 | |
Anna Schumaker | 300ee18569 | |
Anna Schumaker | 24c1a31367 | |
Anna Schumaker | b7f1a05967 | |
Anna Schumaker | c0edbd9bff | |
Anna Schumaker | 0cf5f80eb4 | |
Anna Schumaker | 2dc5d9ed0a | |
Anna Schumaker | aeeee1417a | |
Anna Schumaker | 87606f8fac | |
Anna Schumaker | 51a13a8a04 | |
Anna Schumaker | 1730b7e92c | |
Anna Schumaker | 1b38c4d6ec | |
Anna Schumaker | d3bdaaa063 | |
Anna Schumaker | d57509425b | |
Anna Schumaker | 8a9c90a7ff | |
Anna Schumaker | d22b3c0ce2 | |
Anna Schumaker | 9944d07bba | |
Anna Schumaker | e502a7e8cb | |
Anna Schumaker | 1832a56786 | |
Anna Schumaker | ad3d4840e8 | |
Anna Schumaker | ec5c4ddd2c | |
Anna Schumaker | 6cade5d779 | |
Anna Schumaker | 00f6ee9238 | |
Anna Schumaker | 011dbd114b | |
Anna Schumaker | f85cdb5b49 | |
Anna Schumaker | b3d04805d7 | |
Anna Schumaker | ee8db58fb2 | |
Anna Schumaker | 7ff1a3d60c | |
Anna Schumaker | 000dbd7018 | |
Anna Schumaker | 2ff03bba18 | |
Anna Schumaker | e0becbb059 | |
Anna Schumaker | a5db116d42 | |
Anna Schumaker | 2ed34d3465 | |
Anna Schumaker | 3157c53423 | |
Anna Schumaker | bf8d7fac1b | |
Anna Schumaker | 7cd77d3aed | |
Anna Schumaker | 69c59438c2 | |
Anna Schumaker | b3c2dd25fb | |
Anna Schumaker | 8ec5239acc | |
Anna Schumaker | 4bced82b1f | |
Anna Schumaker | dbc2ec03f2 | |
Anna Schumaker | c434f6672e | |
Anna Schumaker | 997b1de012 | |
Anna Schumaker | 81fdfe66cb | |
Anna Schumaker | c899c15c42 | |
Anna Schumaker | 318b2564ce | |
Anna Schumaker | 35d0d815ca | |
Anna Schumaker | 51096104ce | |
Anna Schumaker | 88e4fa4b0c | |
Anna Schumaker | d105b15e02 | |
Anna Schumaker | 93dc476706 | |
Anna Schumaker | d134b303ab | |
Anna Schumaker | 47bc858630 | |
Anna Schumaker | 5d0d522e3c | |
Anna Schumaker | bb1d01f951 | |
Anna Schumaker | 3f28799437 | |
Anna Schumaker | 081cae4cd8 | |
Anna Schumaker | 847c15f64b | |
Anna Schumaker | 4cd1e89493 | |
Anna Schumaker | 50270bd04c | |
Anna Schumaker | 236a1e60c2 | |
Anna Schumaker | 711fa0da5b | |
Anna Schumaker | 5d3fb980af | |
Anna Schumaker | 47d5f0c0c6 | |
Anna Schumaker | 3cf730a5cc | |
Anna Schumaker | 6ede296ba6 | |
Anna Schumaker | a73063a04c | |
Anna Schumaker | 5d1c11e64e | |
Anna Schumaker | 767f0c1584 | |
Anna Schumaker | b1cd1706ed | |
Anna Schumaker | 788ca374a8 | |
Anna Schumaker | 651f24672b | |
Anna Schumaker | 2eef68f76f | |
Anna Schumaker | 8c8135fc23 | |
Anna Schumaker | deb4f3d252 | |
Anna Schumaker | 61fc252172 | |
Anna Schumaker | 482a199731 | |
Anna Schumaker | 4be26c5fee | |
Anna Schumaker | 5cd5d2640d | |
Anna Schumaker | 4072ea97d4 | |
Anna Schumaker | 08ea7342dc | |
Anna Schumaker | 18743f05c4 | |
Anna Schumaker | ab6eb556ad | |
Anna Schumaker | 1296857189 | |
Anna Schumaker | 73ba296d74 | |
Anna Schumaker | f9cec5e1b3 | |
Anna Schumaker | 0c7a4a4a4c | |
Anna Schumaker | 289420e504 | |
Anna Schumaker | 15059db59a | |
Anna Schumaker | c4adea15bb | |
Anna Schumaker | 328dce0be2 | |
Anna Schumaker | 295202443f | |
Anna Schumaker | b245b2073e | |
Anna Schumaker | 7b89f54e8b | |
Anna Schumaker | b768d74928 | |
Anna Schumaker | beca08b833 | |
Anna Schumaker | db2d122211 | |
Anna Schumaker | 10c5fd4cef | |
Anna Schumaker | 2daefa932c | |
Anna Schumaker | 915e3c8340 | |
Anna Schumaker | 04dc67a097 | |
Anna Schumaker | 5aa9f36272 | |
Anna Schumaker | be7e8e6073 | |
Anna Schumaker | a85ac03517 | |
Anna Schumaker | 853594fc26 | |
Anna Schumaker | 798ef20a72 | |
Anna Schumaker | ba06eca07f | |
Anna Schumaker | 4cdf4c528a | |
Anna Schumaker | 8f26cf9fee | |
Anna Schumaker | bb0a9face7 | |
Anna Schumaker | 2e14b511a4 | |
Anna Schumaker | 6c81981570 | |
Anna Schumaker | c7b205e404 | |
Anna Schumaker | 845de3957b | |
Anna Schumaker | 580358a88e | |
Anna Schumaker | 52415cf4da | |
Anna Schumaker | 2f1b7b397f | |
Anna Schumaker | 44f778bdb7 | |
Anna Schumaker | 981e98818d | |
Anna Schumaker | 44ba5438e2 | |
Anna Schumaker | 7f31e39779 | |
Anna Schumaker | bbe48ccf82 | |
Anna Schumaker | f15514edd1 | |
Anna Schumaker | cee0f4e075 | |
Anna Schumaker | da708a9810 | |
Anna Schumaker | 78647884d6 | |
Anna Schumaker | 594f7991f2 | |
Anna Schumaker | 27ad8d72b4 | |
Anna Schumaker | 45b7f9595c | |
Anna Schumaker | 574d03bad6 | |
Anna Schumaker | 6913cf992d | |
Anna Schumaker | b4daf0e48c | |
Anna Schumaker | 688bd1aa29 | |
Anna Schumaker | 7d5b9b8ba1 | |
Anna Schumaker | dbad19ad46 | |
Anna Schumaker | 50bf64faf3 | |
Anna Schumaker | 289a980390 | |
Anna Schumaker | 0ed71f8792 | |
Anna Schumaker | 44370b265b | |
Anna Schumaker | b09baf3d99 | |
Anna Schumaker | c5aff410b4 | |
Anna Schumaker | 94cb57dbfc | |
Anna Schumaker | c136b8660a | |
Anna Schumaker | 3b15318f7c | |
Anna Schumaker | d0049e4951 | |
Anna Schumaker | fd728a7a99 | |
Anna Schumaker | 2311a3a697 | |
Anna Schumaker | 67d0ba4e44 | |
Anna Schumaker | 36893317c2 | |
Anna Schumaker | 81dc5f1b76 | |
Anna Schumaker | 7c009655ed | |
Anna Schumaker | d7f1f64506 | |
Anna Schumaker | 2ac2ce04aa | |
Anna Schumaker | 0cdc83c21e | |
Anna Schumaker | 8e7db2c472 | |
Anna Schumaker | 4e24124755 | |
Anna Schumaker | 296f0c53b4 | |
Anna Schumaker | df4074f1de | |
Anna Schumaker | 979071cd14 | |
Anna Schumaker | 8adfb51082 | |
Anna Schumaker | 5d4ad35131 | |
Anna Schumaker | 768a3388d7 | |
Anna Schumaker | 9cfbf2acc9 | |
Anna Schumaker | c4954c5bbc | |
Anna Schumaker | 0966950d86 | |
Anna Schumaker | 8d901afae7 | |
Anna Schumaker | e646b12f65 | |
Anna Schumaker | 35e3085c6a | |
Anna Schumaker | fc83b66fbe | |
Anna Schumaker | f2402cdb44 | |
Anna Schumaker | f8dbb71581 | |
Anna Schumaker | 281fda1933 | |
Anna Schumaker | 35e31d0553 | |
Anna Schumaker | 20b84fa019 | |
Anna Schumaker | 6ac08eb2bd | |
Anna Schumaker | 34350d5700 | |
Anna Schumaker | 7be89be250 | |
Anna Schumaker | 5b5d166db3 | |
Anna Schumaker | 5d18c336d5 | |
Anna Schumaker | 0152ba1431 | |
Anna Schumaker | 7beebbc7d1 | |
Anna Schumaker | 16038a16f1 | |
Anna Schumaker | 31695863de | |
Anna Schumaker | 2e4062a515 | |
Anna Schumaker | 9dc466e8f1 | |
Anna Schumaker | 869ab6d274 | |
Anna Schumaker | e1cab1de6f | |
Anna Schumaker | 3bd60b0f06 | |
Anna Schumaker | 0e7cb81476 | |
Anna Schumaker | d1d84af228 | |
Anna Schumaker | b75fc78de7 | |
Anna Schumaker | fdc4bb7275 | |
Anna Schumaker | 0014e5fa55 | |
Anna Schumaker | 59d9c3b484 | |
Anna Schumaker | 1d5a52623c | |
Anna Schumaker | b74f948acb | |
Anna Schumaker | 43ec165a56 | |
Anna Schumaker | c982fe624b | |
Anna Schumaker | 17391acd4d | |
Anna Schumaker | f02104a9c1 | |
Anna Schumaker | b62c7f1554 | |
Anna Schumaker | bc4c3588e6 | |
Anna Schumaker | b05ef737f2 | |
Anna Schumaker | 7979cb1a4a | |
Anna Schumaker | 880f0a686b | |
Anna Schumaker | 97a05efe7e | |
Anna Schumaker | 96956c730d | |
Anna Schumaker | 049eeec38a | |
Anna Schumaker | 03b3c4a806 | |
Anna Schumaker | 20e4ab4ba5 | |
Anna Schumaker | cc88dcab0a | |
Anna Schumaker | 2e57e1fe0a | |
Anna Schumaker | 2f747ccaa6 | |
Anna Schumaker | e94a737718 | |
Anna Schumaker | ee6bf059c1 | |
Anna Schumaker | 0b818bc067 | |
Anna Schumaker | 050a930376 | |
Anna Schumaker | 7a46ffdf47 | |
Anna Schumaker | 8a4590f0ed | |
Anna Schumaker | 23699a601d | |
Anna Schumaker | c658e873a6 | |
Anna Schumaker | 6b5b2a745e | |
Anna Schumaker | f82e299736 | |
Anna Schumaker | d8dbba0960 | |
Anna Schumaker | adfbf8fdbc | |
Anna Schumaker | ea31e1539a | |
Anna Schumaker | 472280ca9b | |
Anna Schumaker | 3d77e8cd2a | |
Anna Schumaker | 2ab67258e9 | |
Anna Schumaker | 8f98dfdde7 | |
Anna Schumaker | b8da049be9 | |
Anna Schumaker | 3afaea664b | |
Anna Schumaker | 53c61160bc | |
Anna Schumaker | 2753480052 | |
Anna Schumaker | 3ae543b8e7 | |
Anna Schumaker | aae99218e0 | |
Anna Schumaker | 64a6fdca2d | |
Anna Schumaker | 584e8ecc05 | |
Anna Schumaker | c9d4441256 | |
Anna Schumaker | 14724aa81e | |
Anna Schumaker | edb6857292 | |
Anna Schumaker | 01de88f474 | |
Anna Schumaker | 0c3afb9d56 | |
Anna Schumaker | 9b4153737b | |
Anna Schumaker | 32dcd83865 | |
Anna Schumaker | f6c72ed081 | |
Anna Schumaker | 932663f872 | |
Anna Schumaker | bba00b3d27 | |
Anna Schumaker | 847f182173 | |
Anna Schumaker | 1d5f88f080 | |
Anna Schumaker | 8917600970 | |
Anna Schumaker | 729b1efc9a | |
Anna Schumaker | 5ff03cf33f | |
Anna Schumaker | 0688088318 | |
Anna Schumaker | 72f654508c | |
Anna Schumaker | 0851aeb0cf | |
Anna Schumaker | a52a815338 | |
Anna Schumaker | 371878a53a | |
Anna Schumaker | 7975988dcc | |
Anna Schumaker | 6f9fb34792 | |
Anna Schumaker | 2aad28f708 | |
Anna Schumaker | 063b93b66f | |
Anna Schumaker | 4235e794bd | |
Anna Schumaker | 67238ed385 | |
Anna Schumaker | 44a002ecac | |
Anna Schumaker | 737d135d41 | |
Anna Schumaker | a1f54839bb | |
Anna Schumaker | 0728579cc4 | |
Anna Schumaker | f7907e4142 | |
Anna Schumaker | 90c6593921 | |
Anna Schumaker | 4141ca211c | |
Anna Schumaker | 8365afc0e3 | |
Anna Schumaker | e6a65f8fe3 | |
Anna Schumaker | 84ad195716 | |
Anna Schumaker | ca3a88557f | |
Anna Schumaker | 6d796e0a89 | |
Anna Schumaker | a4fbd5f2f3 | |
Anna Schumaker | 658be5bef1 | |
Anna Schumaker | feeee8809d | |
Anna Schumaker | 427b9fb925 | |
Anna Schumaker | 9cf1df7c33 | |
Anna Schumaker | 96a6bb1687 | |
Anna Schumaker | 715914c4e3 | |
Anna Schumaker | f14d73ce67 | |
Anna Schumaker | 6fc0fb6b26 | |
Anna Schumaker | e38ce61cf7 | |
Anna Schumaker | 9c5b409d02 | |
Anna Schumaker | 4f4e9efa28 | |
Anna Schumaker | 6792971ef7 | |
Anna Schumaker | d6a442277f | |
Anna Schumaker | 8efb752614 | |
Anna Schumaker | ba1a444bdf | |
Anna Schumaker | 3a50235c38 | |
Anna Schumaker | f55377cc69 | |
Anna Schumaker | 8e509345bf | |
Anna Schumaker | 39794c0830 | |
Anna Schumaker | b95ad55c9a | |
Anna Schumaker | 08696dd17a | |
Anna Schumaker | e467b784e4 | |
Anna Schumaker | 51e8bc295d | |
Anna Schumaker | fa2cbcc261 | |
Anna Schumaker | a4595eab93 | |
Anna Schumaker | a4464cd7d9 | |
Anna Schumaker | c2c6ac7890 | |
Anna Schumaker | 574e49ef09 | |
Anna Schumaker | 990a8047d9 | |
Anna Schumaker | 94235b1ce8 | |
Anna Schumaker | 76bf68f484 | |
Anna Schumaker | ef1d3f0985 | |
Anna Schumaker | ca47bd052f | |
Anna Schumaker | bd49396210 | |
Anna Schumaker | 68f0541079 | |
Anna Schumaker | d551e0ea13 | |
Anna Schumaker | da1211f595 | |
Anna Schumaker | edc3e7f876 | |
Anna Schumaker | 33c7bdf517 | |
Anna Schumaker | ec9ed14474 | |
Anna Schumaker | e4f6018195 | |
Anna Schumaker | e4236b0bf4 | |
Anna Schumaker | 644706ef50 | |
Anna Schumaker | 1c53886152 | |
Anna Schumaker | 753f6477a7 | |
Anna Schumaker | e884dc5a6e | |
Anna Schumaker | ae7c2010e9 | |
Anna Schumaker | 4ab66ef7ab | |
Anna Schumaker | 5c2e4bb016 | |
Anna Schumaker | 596b34eb5a |
|
@ -3,4 +3,8 @@
|
|||
*.coverage
|
||||
*.ui~
|
||||
*.txt
|
||||
*.patch
|
||||
*.tar.gz
|
||||
PKGBUILD
|
||||
emmental.gresource*
|
||||
emmental/mpris2/*.xml
|
||||
|
|
|
@ -1,3 +1,6 @@
|
|||
[submodule "aur"]
|
||||
path = aur
|
||||
url = ssh://aur@aur.archlinux.org/emmental.git
|
||||
[submodule "mpris-spec"]
|
||||
path = mpris-spec
|
||||
url = https://gitlab.freedesktop.org/mpris/mpris-spec.git
|
||||
|
|
92
Makefile
92
Makefile
|
@ -5,36 +5,90 @@ export PREFIX = /usr/local
|
|||
export EMMENTAL_LIB = ${PREFIX}/lib/emmental
|
||||
export EMMENTAL_BIN = ${PREFIX}/bin
|
||||
export EMMENTAL_SHARE = ${PREFIX}/share
|
||||
export EMMENTAL_DESKTOP = ${EMMENTAL_SHARE}/applications/com.nowheycreamery.emmental.desktop
|
||||
|
||||
export EMMENTAL_MAJOR = $(shell grep \^MAJOR lib/version.py | awk -F= '{ gsub(/ /,""); print $$2}')
|
||||
export EMMENTAL_MINOR = $(shell grep \^MINOR lib/version.py | awk -F= '{ gsub(/ /,""); print $$2}')
|
||||
export EMMENTAL_TARGZ = https://git.nowheycreamery.com/anna/emmental/archive/emmental-${EMMENTAL_MAJOR}.${EMMENTAL_MINOR}.tar.gz
|
||||
export EMMENTAL_CSUM = $(shell curl -s ${EMMENTAL_TARGZ} | sha256sum | awk '{print $$1}')
|
||||
all: emmental.gresource mpris2 flake8
|
||||
|
||||
clean:
|
||||
find . -type f -name "*gresource*" -exec rm {} \+
|
||||
find . -type d -name __pycache__ -exec rm -r {} \+
|
||||
find data/ -type d -name "Test Album" -exec rm -r {} \+
|
||||
find data/ -type d -name "Test Library" -exec rm -r {} \+
|
||||
find emmental/mpris2/ -type f -name "*.xml" -exec rm {} \+
|
||||
|
||||
.PHONY:flake8
|
||||
flake8:
|
||||
flake8 emmental/ tests/
|
||||
|
||||
mpris-spec/Makefile:
|
||||
git submodule init mpris-spec
|
||||
git submodule update
|
||||
|
||||
emmental/mpris2/MediaPlayer2.xml: mpris-spec/Makefile
|
||||
cp mpris-spec/spec/org.mpris.MediaPlayer2.xml emmental/mpris2/MediaPlayer2.xml
|
||||
|
||||
emmental/mpris2/Player.xml: mpris-spec/Makefile
|
||||
cp mpris-spec/spec/org.mpris.MediaPlayer2.Player.xml emmental/mpris2/Player.xml
|
||||
|
||||
.PHONY: mpris2
|
||||
mpris2: emmental/mpris2/MediaPlayer2.xml emmental/mpris2/Player.xml
|
||||
|
||||
.PHONY: emmental.gresource.xml
|
||||
emmental.gresource.xml:
|
||||
exec tools/find-resources.py
|
||||
|
||||
.PHONY: emmental.gresource
|
||||
emmental.gresource: emmental.gresource.xml
|
||||
glib-compile-resources emmental.gresource.xml
|
||||
|
||||
.PHONY: install.app
|
||||
install.app:
|
||||
find ./emmental -type f -not -path "*/__pycache__/*" \
|
||||
-exec install -v -C -D -m 755 "{}" "$(EMMENTAL_LIB)/{}" \;
|
||||
install -C -v -m 644 emmental.py $(EMMENTAL_LIB)/emmental.py
|
||||
|
||||
.PHONY: install.icons
|
||||
install.icons:
|
||||
install -C -v -m 644 emmental.gresource $(EMMENTAL_LIB)/emmental.gresource
|
||||
install -C -v -m 644 icons/scalable/apps/emmental.svg $(EMMENTAL_LIB)/emmental.svg
|
||||
|
||||
.PHONY: install.desktop
|
||||
install.desktop:
|
||||
desktop-file-install --set-key=Exec --set-value $(EMMENTAL_BIN)/emmental \
|
||||
--set-key=Icon --set-value=$(EMMENTAL_LIB)/emmental.svg \
|
||||
--rebuild-mime-info-cache \
|
||||
--dir=$(EMMENTAL_SHARE)/applications com.nowheycreamery.emmental.desktop
|
||||
|
||||
.PHONY: install
|
||||
install:
|
||||
exec tools/install.sh
|
||||
install: emmental.gresource mpris2 install.app install.icons install.desktop
|
||||
mkdir -p $(EMMENTAL_BIN)
|
||||
echo -e "#!/bin/bash\npython -O $(EMMENTAL_LIB)/emmental.py \$$*" > $(EMMENTAL_BIN)/emmental
|
||||
chmod 655 $(EMMENTAL_BIN)/emmental
|
||||
|
||||
.PHONY: uninstall
|
||||
uninstall:
|
||||
rm -fv ${EMMENTAL_BIN}/emmental
|
||||
rm -rfv ${EMMENTAL_LIB}
|
||||
rm -fv ${EMMENTAL_SHARE}/icons/hicolor/scalable/apps/emmental*.svg
|
||||
rm -fv ${EMMENTAL_SHARE}/applications/emmental.desktop
|
||||
rm -f ${EMMENTAL_SHARE}/applications/com.nowheycreamery.emmental.desktop
|
||||
rm -f ${EMMENTAL_BIN}/emmental
|
||||
rm -rf ${EMMENTAL_LIB}/emmental/
|
||||
|
||||
.PHONY: pkgbuild.pkgver
|
||||
pkgbuild.pkgver:
|
||||
$(eval MAJOR := $(shell grep \^MAJOR_VERSION emmental/__init__.py | awk -F= '{ gsub(/ /,""); print $$2}'))
|
||||
$(eval MINOR := $(shell grep \^MINOR_VERSION emmental/__init__.py | awk -F= '{ gsub(/ /,""); print $$2}'))
|
||||
$(eval MICRO := $(shell grep \^MICRO_VERSION emmental/__init__.py | awk -F= '{ gsub(/ /,""); print $$2}'))
|
||||
sed -i 's/^pkgver=.*/pkgver=${MAJOR}.${MINOR}.${MICRO}/' aur/PKGBUILD
|
||||
|
||||
.PHONY: pkgbuild.sha256sum
|
||||
pkgbuild.sha256sum:
|
||||
$(eval TAG := $(shell git describe --abbrev=0))
|
||||
$(eval CHECKSUM := $(shell git archive --prefix=emmental/ --format tar.gz $(TAG) | sha256sum | awk '{print $$1}'))
|
||||
sed -i 's/^sha256sums=.*/sha256sums=(${CHECKSUM})/' aur/PKGBUILD
|
||||
|
||||
.PHONY: pkgbuild
|
||||
pkgbuild:
|
||||
cp data/PKGBUILD aur/
|
||||
sed -i 's|{MAJOR}.{MINOR}|${EMMENTAL_MAJOR}.${EMMENTAL_MINOR}|' aur/PKGBUILD
|
||||
sed -i 's|{SHA256SUM}|${EMMENTAL_CSUM}|' aur/PKGBUILD
|
||||
pkgbuild: pkgbuild.pkgver pkgbuild.sha256sum
|
||||
cd aur && makepkg --printsrcinfo > .SRCINFO
|
||||
|
||||
.PHONY: pytest
|
||||
pytest: emmental.gresource mpris2
|
||||
pytest
|
||||
|
||||
.PHONY: tests
|
||||
tests:
|
||||
python tools/generate_tracks.py
|
||||
EMMENTAL_TESTING=1 python -m unittest discover -v
|
||||
tests: pytest flake8
|
||||
|
|
67
README.md
67
README.md
|
@ -1,3 +1,66 @@
|
|||
# emmental
|
||||
# Emmental
|
||||
Emmental is a music player built using Python, GStreamer, and GTK.
|
||||
It tries to make it really easy to listen to your music, the default
|
||||
"Collection" playlist contains all your music files and is a fallback when
|
||||
other playlists run out of tracks.
|
||||
|
||||
A new music player built around Python and GTK
|
||||
## Features
|
||||
* MPRIS2
|
||||
* ReplayGain
|
||||
* Gapless playback
|
||||
* Background listening mode
|
||||
* Automatically pause after a user-configured number of tracks
|
||||
* Playlist creation and management
|
||||
* Automatic playlists based on Artists, Albums, Genres, Decades, and Years
|
||||
* Multiple library path support
|
||||
* Plays all audio formats supported by GStreamer
|
||||
* Renamed and updated tracks detection (using MusicBrainzIDs)
|
||||
|
||||
## Dependencies
|
||||
* Python3
|
||||
* dateutil
|
||||
* gobject
|
||||
* liblistenbrainz
|
||||
* musicbrainzngs
|
||||
* mutagen
|
||||
* pyxdg
|
||||
* GStreamer
|
||||
* GStreamer good plugins (optional)
|
||||
* GStreamer bad plugins (optional)
|
||||
* GStreamer ugly plugins (optional)
|
||||
* GTK4
|
||||
* xdg-user-dirs-gtk
|
||||
* Libadwaita
|
||||
|
||||
## Installing
|
||||
Running `make install` will install Emmental to `/usr/local` by default.
|
||||
This can be changed during install:
|
||||
```
|
||||
PREFIX=/usr make install
|
||||
```
|
||||
|
||||
ArchLinux users can also install Emmental though the
|
||||
[AUR](https://aur.archlinux.org/packages/emmental)
|
||||
|
||||
## Q & A
|
||||
### 1. What's with the name? Why 'emmental'?
|
||||
Emmental was the cheese used in a
|
||||
[late-2018 experiment](https://www.smithsonianmag.com/smart-news/hip-hop-and-mozart-improve-flavor-swiss-cheese-180971721/)
|
||||
to learn if playing music while a cheese ages has an impact on flavor
|
||||
(spoiler alert: it did). I have a habit of naming projects and computers after
|
||||
cheeses, so when I started this project I named it after the cheese used in
|
||||
this experiment.
|
||||
|
||||
### 2. How do I edit my tracks?
|
||||
Emmental doesn't have a built-in tag editor but it can detect when track
|
||||
files have been edited in an external program. I highly recommend using a
|
||||
dedicated tag editing program like
|
||||
[MusicBrainz Picard](https://picard.musicbrainz.org/), it does a much better
|
||||
job at tag editing than I ever will.
|
||||
|
||||
### 3. What is the ReplayGain "Decide automatically" option?
|
||||
ReplayGain has two operating modes, "track" and "album", that the user can
|
||||
select between. Emmental builds on this and can automatically choose between
|
||||
the two based on the source playlist for a given track. This means if the
|
||||
current track comes from an Album playlist, ReplayGain will use "album mode"
|
||||
and if it comes from other playlists it will use "track mode".
|
||||
|
|
|
@ -1,7 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
from . import player
|
||||
from gi.repository import Gst
|
||||
import sys
|
||||
Gst.init(sys.argv)
|
||||
|
||||
Player = player.Player()
|
|
@ -1,46 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
from gi.repository import Gtk, GdkPixbuf, Gst
|
||||
|
||||
class Artwork(Gtk.AspectFrame):
|
||||
def __init__(self):
|
||||
Gtk.AspectFrame.__init__(self)
|
||||
self.picture = Gtk.Picture()
|
||||
|
||||
self.frame = Gtk.Frame()
|
||||
self.frame.set_child(self.picture)
|
||||
|
||||
self.set_child(self.frame)
|
||||
self.set_obey_child(False)
|
||||
self.set_margin_start(5)
|
||||
self.set_margin_end(5)
|
||||
self.set_margin_top(5)
|
||||
self.set_margin_bottom(5)
|
||||
self.set_ratio(1.0)
|
||||
self.reset()
|
||||
|
||||
def get_default_path(self):
|
||||
display = self.picture.get_display()
|
||||
theme = Gtk.IconTheme.get_for_display(display)
|
||||
icon = theme.lookup_icon("emmental", [ ], 1024, 1, 0, 0)
|
||||
return icon.get_file().get_path()
|
||||
|
||||
def set_from_data(self, data):
|
||||
loader = GdkPixbuf.PixbufLoader()
|
||||
loader.write(data)
|
||||
|
||||
pixbuf = loader.get_pixbuf()
|
||||
self.picture.set_pixbuf(pixbuf)
|
||||
loader.close()
|
||||
|
||||
def set_from_sample(self, sample):
|
||||
buffer = sample.get_buffer()
|
||||
|
||||
(res, map) = buffer.map(Gst.MapFlags.READ)
|
||||
if res == True:
|
||||
self.set_from_data(map.data)
|
||||
buffer.unmap(map)
|
||||
else:
|
||||
self.reset()
|
||||
|
||||
def reset(self):
|
||||
self.picture.set_filename(self.get_default_path())
|
|
@ -1,39 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
from . import menu
|
||||
from gi.repository import Gtk, Gst
|
||||
|
||||
class Controls(Gtk.Box):
|
||||
def __init__(self):
|
||||
Gtk.Box.__init__(self)
|
||||
self.add_css_class("large-icons")
|
||||
self.add_css_class("linked")
|
||||
|
||||
self.previous = Gtk.Button.new_from_icon_name("media-skip-backward")
|
||||
self.append(self.previous)
|
||||
|
||||
self.play = Gtk.Button.new_from_icon_name("media-playback-start")
|
||||
self.append(self.play)
|
||||
|
||||
self.pause = Gtk.Button.new_from_icon_name("media-playback-pause")
|
||||
self.pause.hide()
|
||||
self.append(self.pause)
|
||||
|
||||
self.next = Gtk.Button.new_from_icon_name("media-skip-forward")
|
||||
self.append(self.next)
|
||||
|
||||
self.menu = menu.Button()
|
||||
self.append(self.menu)
|
||||
|
||||
self.sizegroup = Gtk.SizeGroup()
|
||||
self.sizegroup.add_widget(self)
|
||||
|
||||
def connect(self, name, func):
|
||||
if name == "volume-changed":
|
||||
self.menu.volume.connect("value-changed", func)
|
||||
else:
|
||||
button = self.__dict__.get(name)
|
||||
button.connect("clicked", func)
|
||||
|
||||
def set_state(self, state):
|
||||
self.play.set_visible(state != Gst.State.PLAYING)
|
||||
self.pause.set_visible(state == Gst.State.PLAYING)
|
|
@ -1,87 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
from lib import settings
|
||||
from gi.repository import Gtk
|
||||
import tagdb
|
||||
|
||||
class Button(Gtk.MenuButton):
|
||||
def __init__(self):
|
||||
Gtk.MenuButton.__init__(self)
|
||||
|
||||
self.count = Gtk.Label()
|
||||
self.count.set_yalign(0)
|
||||
self.count.set_markup("<small> </small>")
|
||||
|
||||
self.pause = Gtk.Image.new_from_icon_name("media-playback-start")
|
||||
self.counter = Gtk.Scale()
|
||||
self.counter.set_adjustment(tagdb.Stack.Counter)
|
||||
self.counter.connect("value-changed", self.on_counter_changed)
|
||||
self.counter.set_format_value_func(self.format_counter)
|
||||
self.counter.set_digits(0)
|
||||
self.counter.set_draw_value(True)
|
||||
|
||||
settings.initialize("audio.volume", 1.0)
|
||||
self.vol_img = Gtk.Image()
|
||||
self.volume = Gtk.Scale.new_with_range(Gtk.Orientation.HORIZONTAL,
|
||||
0.0, 1.0, 0.05)
|
||||
self.volume.connect("value-changed", self.on_volume_changed)
|
||||
self.volume.set_value(settings.get_float("audio.volume"))
|
||||
self.volume.set_format_value_func(self.format_volume)
|
||||
self.volume.set_draw_value(True)
|
||||
self.on_volume_changed(self.volume)
|
||||
|
||||
self.grid = Gtk.Grid()
|
||||
self.grid.attach(self.pause, 0, 0, 1, 1)
|
||||
self.grid.attach(self.counter, 1, 0, 1, 1)
|
||||
self.grid.attach(self.vol_img, 0, 1, 1, 1)
|
||||
self.grid.attach(self.volume, 1, 1, 1, 1)
|
||||
self.grid.add_css_class("large-icons")
|
||||
self.grid.set_column_spacing(5)
|
||||
|
||||
self.popover = Gtk.Popover()
|
||||
self.popover.set_child(self.grid)
|
||||
|
||||
self.overlay = Gtk.Overlay()
|
||||
self.toggle = self.get_first_child()
|
||||
self.icon = self.toggle.get_child()
|
||||
self.icon.set_margin_top(5)
|
||||
self.toggle.set_child(self.overlay)
|
||||
self.overlay.add_overlay(self.count)
|
||||
self.overlay.add_overlay(self.icon)
|
||||
|
||||
self.set_popover(self.popover)
|
||||
self.add_css_class("normal-icons")
|
||||
|
||||
def format_counter(self, scale, value):
|
||||
value = int(value)
|
||||
if value == -1:
|
||||
return "Keep Playing"
|
||||
elif value == 0:
|
||||
return "This Track"
|
||||
elif value == 1:
|
||||
return "Next Track"
|
||||
return f"{value} Tracks"
|
||||
|
||||
def format_volume(self, scale, value):
|
||||
return f"{int(value*100)}%"
|
||||
|
||||
def get_volume(self):
|
||||
return self.volume.get_value()
|
||||
|
||||
def on_counter_changed(self, scale):
|
||||
value = int(scale.get_value())
|
||||
icon = "pause" if value > -1 else "start"
|
||||
text = " " if value == -1 else value
|
||||
self.pause.set_from_icon_name(f"media-playback-{icon}")
|
||||
self.count.set_markup(f"<small>{text}</small>")
|
||||
|
||||
def on_volume_changed(self, scale):
|
||||
value = scale.get_value()
|
||||
settings.set("audio.volume", value)
|
||||
if value == 0:
|
||||
self.vol_img.set_from_icon_name("audio-volume-muted-symbolic")
|
||||
elif value < 1/3:
|
||||
self.vol_img.set_from_icon_name("audio-volume-low-symbolic")
|
||||
elif value < 2/3:
|
||||
self.vol_img.set_from_icon_name("audio-volume-medium-symbolic")
|
||||
else:
|
||||
self.vol_img.set_from_icon_name("audio-volume-high-symbolic")
|
|
@ -1,38 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
from gi.repository import GLib, Gtk
|
||||
|
||||
class NowPlaying(Gtk.ScrolledWindow):
|
||||
def __init__(self):
|
||||
Gtk.ScrolledWindow.__init__(self)
|
||||
self.title = Gtk.Label()
|
||||
self.title.add_css_class("title")
|
||||
|
||||
self.subtitle = Gtk.Label()
|
||||
self.subtitle.add_css_class("subtitle")
|
||||
|
||||
self.box = Gtk.Box.new(Gtk.Orientation.VERTICAL, 0)
|
||||
self.box.append(self.title)
|
||||
self.box.append(self.subtitle)
|
||||
|
||||
self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER)
|
||||
self.set_valign(Gtk.Align.CENTER)
|
||||
self.set_hexpand(True)
|
||||
self.set_child(self.box)
|
||||
|
||||
self.set_title(None)
|
||||
self.set_subtitle(None)
|
||||
|
||||
def set_artist(self, text):
|
||||
self.set_subtitle(f"by {text}")
|
||||
|
||||
def set_title(self, text):
|
||||
if text == None:
|
||||
text = "Emmental"
|
||||
text = GLib.markup_escape_text(text)
|
||||
self.title.set_markup(f"<big>{text}</big>")
|
||||
|
||||
def set_subtitle(self, text):
|
||||
if text == None:
|
||||
text = "The Cheesy Music Player"
|
||||
text = GLib.markup_escape_text(text)
|
||||
self.subtitle.set_markup(f"<big>{text}</big>")
|
137
audio/player.py
137
audio/player.py
|
@ -1,137 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
from . import artwork
|
||||
from . import controls
|
||||
from . import nowplaying
|
||||
from . import seeker
|
||||
from lib import publisher
|
||||
from lib import settings
|
||||
from gi.repository import Gst, GLib
|
||||
import tagdb
|
||||
|
||||
class Player:
|
||||
def __init__(self):
|
||||
self.video = Gst.ElementFactory.make("fakesink")
|
||||
self.playbin = Gst.ElementFactory.make("playbin")
|
||||
self.playbin.set_property("video-sink", self.video)
|
||||
|
||||
self.bus = self.playbin.get_bus()
|
||||
self.bus.add_signal_watch()
|
||||
self.bus.connect("message::eos", self.next)
|
||||
self.bus.connect("message::state-changed", self.on_state_changed)
|
||||
self.bus.connect("message::tag", self.on_tag)
|
||||
|
||||
self.Controls = controls.Controls()
|
||||
self.Controls.connect("previous", self.previous)
|
||||
self.Controls.connect("play", self.play)
|
||||
self.Controls.connect("pause", self.pause)
|
||||
self.Controls.connect("next", self.next)
|
||||
self.Controls.connect("volume-changed", self.volume_changed)
|
||||
|
||||
self.NowPlaying = nowplaying.NowPlaying()
|
||||
self.Artwork = artwork.Artwork()
|
||||
|
||||
self.Seeker = seeker.Seeker()
|
||||
self.Seeker.connect(self.seeked)
|
||||
self.Controls.sizegroup.add_widget(self.Seeker.scale)
|
||||
GLib.timeout_add(250, self.update_progress)
|
||||
|
||||
self.TrackChanged = publisher.Publisher()
|
||||
self.track = tagdb.Tracks[settings.get_int("audio.trackid")]
|
||||
self.load_set_state(self.track, Gst.State.PAUSED)
|
||||
if self.track:
|
||||
self.track.add_to_playlist("Previous")
|
||||
self.volume_changed()
|
||||
|
||||
def duration(self):
|
||||
(res, dur) = self.playbin.query_duration(Gst.Format.TIME)
|
||||
return dur if res == True else 0
|
||||
|
||||
def get_state(self):
|
||||
(ret, state, pending) = self.playbin.get_state(Gst.CLOCK_TIME_NONE)
|
||||
if ret == Gst.StateChangeReturn.SUCCESS:
|
||||
return state
|
||||
return ret
|
||||
|
||||
def load_track(self, track):
|
||||
prev = self.track
|
||||
self.track = track
|
||||
if track is not None:
|
||||
settings.set("audio.trackid", track.trackid)
|
||||
uri = track.filepath().absolute().as_uri()
|
||||
self.playbin.set_property("uri", uri)
|
||||
self.TrackChanged.publish(prev, self.track)
|
||||
|
||||
def load_set_state(self, track, state):
|
||||
self.playbin.set_state(Gst.State.READY)
|
||||
self.load_track(track)
|
||||
if track is not None:
|
||||
self.playbin.set_state(state)
|
||||
|
||||
def next(self, *args):
|
||||
duration = self.duration()
|
||||
if duration > 0 and (self.runtime() / duration) > (2 / 3):
|
||||
self.track.played()
|
||||
|
||||
(track, cont) = tagdb.Stack.next()
|
||||
state = Gst.State.PLAYING if cont else Gst.State.PAUSED
|
||||
self.load_set_state(track, state)
|
||||
|
||||
def on_state_changed(self, bus, message):
|
||||
(old, new, pending) = message.parse_state_changed()
|
||||
self.Controls.set_state(new)
|
||||
|
||||
def on_tag(self, bus, message):
|
||||
taglist = message.parse_tag()
|
||||
(res, title) = taglist.get_string("title")
|
||||
if res == True:
|
||||
self.NowPlaying.set_title(title)
|
||||
(res, artist) = taglist.get_string("artist")
|
||||
if res == True:
|
||||
self.NowPlaying.set_artist(artist)
|
||||
(res, sample) = taglist.get_sample("image")
|
||||
if res == True:
|
||||
self.Artwork.set_from_sample(sample)
|
||||
else:
|
||||
self.Artwork.reset()
|
||||
|
||||
def pause(self, *args):
|
||||
self.playbin.set_state(Gst.State.PAUSED)
|
||||
|
||||
def play(self, *args):
|
||||
self.playbin.set_state(Gst.State.PLAYING)
|
||||
|
||||
def playpause(self, *args):
|
||||
if self.get_state() == Gst.State.PLAYING:
|
||||
self.pause()
|
||||
else:
|
||||
self.play()
|
||||
|
||||
def play_track(self, track):
|
||||
if track == self.track:
|
||||
return False
|
||||
self.load_set_state(track, Gst.State.PLAYING)
|
||||
return True
|
||||
|
||||
def position(self):
|
||||
(res, pos) = self.playbin.query_position(Gst.Format.TIME)
|
||||
return pos if res == True else 0
|
||||
|
||||
def previous(self, *args):
|
||||
self.play_track(tagdb.Stack.previous())
|
||||
|
||||
def runtime(self):
|
||||
if self.playbin.clock == None:
|
||||
return 0
|
||||
return self.playbin.clock.get_time() - self.playbin.base_time
|
||||
|
||||
def seeked(self, scale, scroll, value):
|
||||
self.playbin.seek_simple(Gst.Format.TIME, Gst.SeekFlags.FLUSH,
|
||||
value * Gst.SECOND)
|
||||
|
||||
def update_progress(self):
|
||||
self.Seeker.configure(self.position() / Gst.SECOND,
|
||||
self.duration() / Gst.SECOND)
|
||||
return GLib.SOURCE_CONTINUE
|
||||
|
||||
def volume_changed(self, *args):
|
||||
self.playbin.set_property("volume", self.Controls.menu.volume.get_value())
|
|
@ -1,35 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
from gi.repository import Gtk
|
||||
|
||||
class Seeker(Gtk.Box):
|
||||
def __init__(self):
|
||||
Gtk.Box.__init__(self)
|
||||
|
||||
self.position = Gtk.Label.new(str="00:00")
|
||||
self.remaining = Gtk.Label.new(str="00:00")
|
||||
|
||||
self.adjustment = Gtk.Adjustment()
|
||||
self.adjustment.set_step_increment(10)
|
||||
|
||||
self.scale = Gtk.Scale()
|
||||
self.scale.set_adjustment(self.adjustment)
|
||||
|
||||
self.append(self.position)
|
||||
self.append(self.scale)
|
||||
self.append(self.remaining)
|
||||
|
||||
def configure(self, position, duration):
|
||||
self.adjustment.set_upper(duration)
|
||||
self.adjustment.set_value(position)
|
||||
|
||||
(m, s) = divmod(int(position), 60)
|
||||
self.position.set_text(f"{m:02}:{s:02}")
|
||||
|
||||
(m, s) = divmod(int(duration - position), 60)
|
||||
self.remaining.set_text(f"{m:02}:{s:02}")
|
||||
|
||||
def connect(self, func):
|
||||
self.scale.connect("change-value", func)
|
||||
|
||||
def get_position(self):
|
||||
return self.scale.get_value()
|
|
@ -1,27 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
from . import artwork
|
||||
from gi.repository import Gtk
|
||||
import pathlib
|
||||
import unittest
|
||||
|
||||
Path = pathlib.Path("./data/hicolor/scalable/apps/emmental.svg")
|
||||
|
||||
class TestAudioArtwork(unittest.TestCase):
|
||||
def test_audio_artwork_init(self):
|
||||
art = artwork.Artwork()
|
||||
|
||||
self.assertIsInstance(art, Gtk.AspectFrame)
|
||||
self.assertIsInstance(art.frame, Gtk.Frame)
|
||||
self.assertIsInstance(art.picture, Gtk.Picture)
|
||||
|
||||
self.assertEqual(art.get_child(), art.frame)
|
||||
self.assertEqual(art.frame.get_child(), art.picture)
|
||||
self.assertEqual(art.get_obey_child(), False)
|
||||
self.assertEqual(art.get_ratio(), 1.0)
|
||||
|
||||
self.assertEqual(art.get_margin_start(), 5)
|
||||
self.assertEqual(art.get_margin_end(), 5)
|
||||
self.assertEqual(art.get_margin_top(), 5)
|
||||
self.assertEqual(art.get_margin_bottom(), 5)
|
||||
|
||||
self.assertIsNotNone(art.get_default_path())
|
|
@ -1,50 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
from . import controls
|
||||
from lib import settings
|
||||
from gi.repository import Gtk, Gst, GLib
|
||||
import unittest
|
||||
|
||||
main_context = GLib.main_context_default()
|
||||
|
||||
class TestControls(unittest.TestCase):
|
||||
def test_controls_init(self):
|
||||
ctrl = controls.Controls()
|
||||
|
||||
self.assertIsInstance(ctrl, Gtk.Box)
|
||||
self.assertIsInstance(ctrl.previous, Gtk.Button)
|
||||
self.assertIsInstance(ctrl.play, Gtk.Button)
|
||||
self.assertIsInstance(ctrl.pause, Gtk.Button)
|
||||
self.assertIsInstance(ctrl.next, Gtk.Button)
|
||||
self.assertIsInstance(ctrl.menu, Gtk.MenuButton)
|
||||
self.assertIsInstance(ctrl.sizegroup, Gtk.SizeGroup)
|
||||
|
||||
self.assertEqual(ctrl.get_orientation(), Gtk.Orientation.HORIZONTAL)
|
||||
self.assertEqual(ctrl.previous.get_icon_name(), "media-skip-backward")
|
||||
self.assertEqual(ctrl.play.get_icon_name(), "media-playback-start")
|
||||
self.assertEqual(ctrl.pause.get_icon_name(), "media-playback-pause")
|
||||
self.assertEqual(ctrl.next.get_icon_name(), "media-skip-forward")
|
||||
|
||||
self.assertTrue(ctrl.has_css_class("linked"))
|
||||
self.assertTrue(ctrl.has_css_class("large-icons"))
|
||||
self.assertTrue(ctrl.menu.has_css_class("normal-icons"))
|
||||
self.assertFalse(ctrl.pause.is_visible())
|
||||
|
||||
self.assertIn(ctrl.previous, ctrl)
|
||||
self.assertIn(ctrl.play, ctrl)
|
||||
self.assertIn(ctrl.pause, ctrl)
|
||||
self.assertIn(ctrl.next, ctrl)
|
||||
self.assertIn(ctrl.menu, ctrl)
|
||||
self.assertIn(ctrl, ctrl.sizegroup.get_widgets())
|
||||
|
||||
def test_controls_state(self):
|
||||
ctrl = controls.Controls()
|
||||
self.assertTrue(ctrl.play.is_visible())
|
||||
self.assertFalse(ctrl.pause.is_visible())
|
||||
|
||||
ctrl.set_state(Gst.State.PLAYING)
|
||||
self.assertFalse(ctrl.play.is_visible())
|
||||
self.assertTrue(ctrl.pause.is_visible())
|
||||
|
||||
ctrl.set_state(Gst.State.READY)
|
||||
self.assertTrue(ctrl.play.is_visible())
|
||||
self.assertFalse(ctrl.pause.is_visible())
|
|
@ -1,108 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
from . import menu
|
||||
from lib import settings
|
||||
from gi.repository import Gtk
|
||||
import tagdb
|
||||
import unittest
|
||||
|
||||
class TestAudioMenu(unittest.TestCase):
|
||||
def setUp(self):
|
||||
settings.reset()
|
||||
|
||||
def test_audio_menu_init(self):
|
||||
button = menu.Button()
|
||||
|
||||
self.assertIsInstance(button, Gtk.MenuButton)
|
||||
self.assertIsInstance(button.popover, Gtk.Popover)
|
||||
self.assertIsInstance(button.overlay, Gtk.Overlay)
|
||||
self.assertIsInstance(button.toggle, Gtk.ToggleButton)
|
||||
self.assertIsInstance(button.grid, Gtk.Grid)
|
||||
self.assertIsNotNone(button.icon)
|
||||
|
||||
self.assertTrue(button.has_css_class("normal-icons"))
|
||||
self.assertTrue(button.grid.has_css_class("large-icons"))
|
||||
|
||||
self.assertEqual(button.grid.get_column_spacing(), 5)
|
||||
self.assertEqual(button.get_popover(), button.popover)
|
||||
self.assertEqual(button.popover.get_child(), button.grid)
|
||||
self.assertEqual(button.toggle, button.get_first_child())
|
||||
self.assertEqual(button.toggle.get_child(), button.overlay)
|
||||
self.assertEqual(button.icon.get_margin_top(), 5)
|
||||
|
||||
self.assertIn(button.icon, button.overlay)
|
||||
|
||||
def test_audio_menu_counter_init(self):
|
||||
button = menu.Button()
|
||||
|
||||
self.assertIsInstance(button.pause, Gtk.Image)
|
||||
self.assertIsInstance(button.count, Gtk.Label)
|
||||
self.assertIsInstance(button.counter, Gtk.Range)
|
||||
|
||||
self.assertEqual(button.pause.get_icon_name(), "media-playback-start")
|
||||
self.assertEqual(button.count.get_text(), " ")
|
||||
self.assertEqual(button.count.get_yalign(), 0)
|
||||
self.assertEqual(button.counter.get_adjustment(), tagdb.Stack.Counter)
|
||||
self.assertEqual(button.counter.get_digits(), 0)
|
||||
self.assertTrue(button.counter.get_draw_value())
|
||||
|
||||
self.assertIn(button.pause, button.grid)
|
||||
self.assertIn(button.counter, button.grid)
|
||||
self.assertIn(button.count, button.overlay)
|
||||
|
||||
def test_audio_menu_counter(self):
|
||||
button = menu.Button()
|
||||
|
||||
self.assertEqual(button.format_counter(button.counter, -1), "Keep Playing")
|
||||
self.assertEqual(button.format_counter(button.counter, 0), "This Track")
|
||||
self.assertEqual(button.format_counter(button.counter, 1), "Next Track")
|
||||
self.assertEqual(button.format_counter(button.counter, 2), "2 Tracks")
|
||||
|
||||
tagdb.Stack.Counter.increment()
|
||||
self.assertEqual(button.pause.get_icon_name(), "media-playback-pause")
|
||||
self.assertEqual(button.count.get_text(), "0")
|
||||
|
||||
tagdb.Stack.Counter.decrement()
|
||||
self.assertEqual(button.pause.get_icon_name(), "media-playback-start")
|
||||
self.assertEqual(button.count.get_text(), " ")
|
||||
|
||||
def test_audio_menu_volume_init(self):
|
||||
button = menu.Button()
|
||||
adjustment = button.volume.get_adjustment()
|
||||
|
||||
self.assertIsInstance(button.vol_img, Gtk.Image)
|
||||
self.assertIsInstance(button.volume, Gtk.Scale)
|
||||
|
||||
self.assertTrue(button.volume.get_draw_value())
|
||||
|
||||
self.assertEqual(settings.get_float("audio.volume"), 1.0)
|
||||
self.assertEqual(adjustment.get_lower(), 0.0)
|
||||
self.assertEqual(adjustment.get_upper(), 1.0)
|
||||
self.assertEqual(adjustment.get_step_increment(), 0.05)
|
||||
self.assertEqual(adjustment.get_value(), 1.0)
|
||||
self.assertEqual(button.vol_img.get_icon_name(), "audio-volume-high-symbolic")
|
||||
|
||||
self.assertIn(button.vol_img, button.grid)
|
||||
self.assertIn(button.volume, button.grid)
|
||||
|
||||
def test_audio_menu_volume(self):
|
||||
button = menu.Button()
|
||||
|
||||
button.volume.set_value(0)
|
||||
self.assertEqual(button.vol_img.get_icon_name(), "audio-volume-muted-symbolic")
|
||||
self.assertEqual(settings.get("audio.volume"), "0.0")
|
||||
self.assertEqual(button.get_volume(), 0.0)
|
||||
|
||||
button.volume.set_value(0.3)
|
||||
self.assertEqual(button.vol_img.get_icon_name(), "audio-volume-low-symbolic")
|
||||
self.assertEqual(settings.get("audio.volume"), "0.3")
|
||||
self.assertEqual(button.get_volume(), 0.3)
|
||||
|
||||
button.volume.set_value(0.6)
|
||||
self.assertEqual(button.vol_img.get_icon_name(), "audio-volume-medium-symbolic")
|
||||
self.assertEqual(settings.get("audio.volume"), "0.6")
|
||||
self.assertEqual(button.get_volume(), 0.6)
|
||||
|
||||
button.volume.set_value(0.9)
|
||||
self.assertEqual(button.vol_img.get_icon_name(), "audio-volume-high-symbolic")
|
||||
self.assertEqual(settings.get("audio.volume"), "0.9")
|
||||
self.assertEqual(button.get_volume(), 0.9)
|
|
@ -1,44 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
from . import nowplaying
|
||||
from gi.repository import Gtk
|
||||
import unittest
|
||||
|
||||
class TestNowPlaying(unittest.TestCase):
|
||||
def test_now_playing_init(self):
|
||||
now = nowplaying.NowPlaying()
|
||||
|
||||
self.assertIsInstance(now, Gtk.ScrolledWindow)
|
||||
self.assertIsInstance(now.box, Gtk.Box)
|
||||
self.assertIsInstance(now.title, Gtk.Label)
|
||||
self.assertIsInstance(now.subtitle, Gtk.Label)
|
||||
|
||||
self.assertIn(now.title, now.box)
|
||||
self.assertIn(now.subtitle, now.box)
|
||||
|
||||
viewport = now.get_child()
|
||||
self.assertEqual(viewport.get_child(), now.box)
|
||||
|
||||
self.assertEqual(now.get_valign(), Gtk.Align.CENTER)
|
||||
self.assertEqual(now.get_policy(), (Gtk.PolicyType.AUTOMATIC,
|
||||
Gtk.PolicyType.NEVER))
|
||||
|
||||
self.assertTrue(now.get_hexpand())
|
||||
self.assertTrue(now.title.has_css_class("title"))
|
||||
self.assertTrue(now.subtitle.has_css_class("subtitle"))
|
||||
|
||||
def test_now_playing_text(self):
|
||||
now = nowplaying.NowPlaying()
|
||||
self.assertEqual(now.title.get_text(), "Emmental")
|
||||
self.assertEqual(now.subtitle.get_text(), "The Cheesy Music Player")
|
||||
|
||||
now.set_title("Test Title")
|
||||
now.set_artist("Test Artist")
|
||||
|
||||
self.assertEqual(now.title.get_text(), "Test Title")
|
||||
self.assertEqual(now.subtitle.get_text(), "by Test Artist")
|
||||
|
||||
now.set_title(None)
|
||||
now.set_subtitle(None)
|
||||
|
||||
self.assertEqual(now.title.get_text(), "Emmental")
|
||||
self.assertEqual(now.subtitle.get_text(), "The Cheesy Music Player")
|
|
@ -1,107 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
from . import artwork
|
||||
from . import controls
|
||||
from . import nowplaying
|
||||
from . import player
|
||||
from . import seeker
|
||||
from lib import publisher
|
||||
from lib import settings
|
||||
from gi.repository import Gst
|
||||
import pathlib
|
||||
import tagdb
|
||||
import unittest
|
||||
|
||||
test_album = pathlib.Path("./data/Test Album/")
|
||||
test_track = test_album / "01 - Test Track.ogg"
|
||||
|
||||
|
||||
class TestPlayer(unittest.TestCase):
|
||||
def setUpClass():
|
||||
tagdb.reset()
|
||||
lib = tagdb.Library.add(test_album)
|
||||
lib.scan().join()
|
||||
|
||||
def setUp(self):
|
||||
self.changed = None
|
||||
settings.reset()
|
||||
self.library = tagdb.Library.store[test_album]
|
||||
self.track = [ t for t in self.library.tracks if t.tracknumber == 1 ][0]
|
||||
|
||||
def tearDownClass():
|
||||
tagdb.reset()
|
||||
|
||||
def on_track_changed(self, prev, new):
|
||||
self.changed = (prev, new)
|
||||
|
||||
def test_player_init(self):
|
||||
play = player.Player()
|
||||
self.assertIsInstance(play.video, Gst.Element)
|
||||
self.assertIsInstance(play.playbin, Gst.Element)
|
||||
self.assertIsInstance(play.bus, Gst.Bus)
|
||||
self.assertIsInstance(play.Controls, controls.Controls)
|
||||
self.assertIsInstance(play.NowPlaying, nowplaying.NowPlaying)
|
||||
self.assertIsInstance(play.Artwork, artwork.Artwork)
|
||||
self.assertIsInstance(play.Seeker, seeker.Seeker)
|
||||
self.assertIsInstance(play.TrackChanged, publisher.Publisher)
|
||||
self.assertIsNone(play.track)
|
||||
|
||||
self.assertEqual(play.playbin.get_property("video-sink"), play.video)
|
||||
self.assertIn(play.Seeker.scale, play.Controls.sizegroup.get_widgets())
|
||||
|
||||
def test_player_load_track(self):
|
||||
play = player.Player()
|
||||
uri = test_track.absolute().as_uri()
|
||||
play.TrackChanged.register(self.on_track_changed)
|
||||
|
||||
self.assertEqual(play.playbin.get_property("uri"), None)
|
||||
|
||||
play.load_track(self.track)
|
||||
self.assertEqual(play.playbin.get_property("uri"), uri)
|
||||
self.assertEqual(play.track, self.track)
|
||||
self.assertEqual(settings.get_int("audio.trackid"), self.track.trackid)
|
||||
self.assertEqual(play.get_state(), Gst.State.READY)
|
||||
self.assertEqual(self.changed, (None, self.track) )
|
||||
self.assertFalse(play.play_track(self.track))
|
||||
|
||||
tagdb.tags.User["Previous"].tracks.clear()
|
||||
play2 = player.Player()
|
||||
self.assertEqual(play2.track, self.track)
|
||||
self.assertIn(self.track, tagdb.tags.User["Previous"].tracks)
|
||||
|
||||
def test_player_play_pause(self):
|
||||
play = player.Player()
|
||||
|
||||
play.load_track(self.track)
|
||||
self.assertEqual(play.track, self.track)
|
||||
self.assertEqual(play.get_state(), Gst.State.READY)
|
||||
|
||||
play.pause()
|
||||
self.assertEqual(play.get_state(), Gst.State.PAUSED)
|
||||
|
||||
play.play()
|
||||
self.assertEqual(play.get_state(), Gst.State.PLAYING)
|
||||
|
||||
play.playpause()
|
||||
self.assertEqual(play.get_state(), Gst.State.PAUSED)
|
||||
|
||||
play.playpause()
|
||||
self.assertEqual(play.get_state(), Gst.State.PLAYING)
|
||||
|
||||
play.pause()
|
||||
self.assertEqual(play.get_state(), Gst.State.PAUSED)
|
||||
|
||||
def test_player_next_previous(self):
|
||||
play = player.Player()
|
||||
play.TrackChanged.register(self.on_track_changed)
|
||||
|
||||
play.next()
|
||||
self.assertEqual(play.track.trackid, 0)
|
||||
self.assertEqual(self.changed, (None, tagdb.Tracks[0]) )
|
||||
|
||||
play.next()
|
||||
self.assertEqual(play.track.trackid, 1)
|
||||
self.assertEqual(self.changed, (tagdb.Tracks[0], tagdb.Tracks[1]) )
|
||||
|
||||
play.previous()
|
||||
self.assertEqual(play.track.trackid, 0)
|
||||
self.assertEqual(self.changed, (tagdb.Tracks[1], tagdb.Tracks[0]) )
|
|
@ -1,40 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
from . import seeker
|
||||
from gi.repository import Gtk
|
||||
import unittest
|
||||
|
||||
class TestSeeker(unittest.TestCase):
|
||||
def test_seeker_init(self):
|
||||
seek = seeker.Seeker()
|
||||
|
||||
self.assertIsInstance(seek, Gtk.Box)
|
||||
self.assertIsInstance(seek.position, Gtk.Label)
|
||||
self.assertIsInstance(seek.remaining, Gtk.Label)
|
||||
self.assertIsInstance(seek.adjustment, Gtk.Adjustment)
|
||||
self.assertIsInstance(seek.scale, Gtk.Scale)
|
||||
|
||||
self.assertEqual(seek.position.get_text(), "00:00")
|
||||
self.assertEqual(seek.remaining.get_text(), "00:00")
|
||||
self.assertEqual(seek.adjustment.get_step_increment(), 10)
|
||||
self.assertEqual(seek.scale.get_adjustment(), seek.adjustment)
|
||||
|
||||
self.assertIn(seek.position, seek)
|
||||
self.assertIn(seek.scale, seek)
|
||||
self.assertIn(seek.remaining, seek)
|
||||
|
||||
def test_seeker_configure(self):
|
||||
seek = seeker.Seeker()
|
||||
|
||||
seek.configure(10, 100)
|
||||
self.assertEqual(seek.adjustment.get_upper(), 100)
|
||||
self.assertEqual(seek.adjustment.get_value(), 10)
|
||||
self.assertEqual(seek.position.get_text(), "00:10")
|
||||
self.assertEqual(seek.remaining.get_text(), "01:30")
|
||||
self.assertEqual(seek.get_position(), 10)
|
||||
|
||||
seek.configure(65.25, 124.2)
|
||||
self.assertEqual(seek.adjustment.get_upper(), 124.2)
|
||||
self.assertEqual(seek.adjustment.get_value(), 65.25)
|
||||
self.assertEqual(seek.position.get_text(), "01:05")
|
||||
self.assertEqual(seek.remaining.get_text(), "00:58")
|
||||
self.assertEqual(seek.get_position(), 65.25)
|
2
aur
2
aur
|
@ -1 +1 @@
|
|||
Subproject commit 3335273a576bf283178c79c5b55025b58997b1f0
|
||||
Subproject commit 543220f35990f5b5a69eac5a6c06e69eae6ffb82
|
|
@ -0,0 +1,12 @@
|
|||
[Desktop Entry]
|
||||
Type=Application
|
||||
Version=1.5
|
||||
Name=Emmental
|
||||
GenericName=Music Player
|
||||
Comment=The Cheesy Music Player
|
||||
DBusActivatable=false
|
||||
Terminal=false
|
||||
MimeType=application/musepack;application/ogg;application/x-ape;application/x-flac;application/x-id3;application/x-musepack;application/x-ogg;application/x-ogm-audio;audio/aac;audio/ape;audio/flac;audio/mp;audio/mp3;audio/mp4;audio/mpc;audio/mpeg;audio/mpeg3;audio/mpegurl;audio/musepack;audio/ogg;audio/vnd.rn-realaudio;audio/vorbis;audio/x-ape;audio/x-flac;audio/x-it;audio/x-m4a;audio/x-mod;audio/x-mp;audio/x-mp3;audio/x-mpc;audio/x-mpeg;audio/x-mpeg-3;audio/x-mpegurl;audio/x-ms-wma;audio/x-musepack;audio/x-ogg;audio/x-oggflac;audio/x-pn-realaudio;audio/x-s3m;audio/x-scpls;audio/x-speex;audio/x-stm;audio/x-vorbis;audio/x-vorbis+ogg;audio/x-wav;audio/x-xm;
|
||||
Categories=AudioVideo;Audio;Music;Player;GTK;GNOME;
|
||||
SingleMainWindow=true
|
||||
StartupWMClass=emmental.py
|
|
@ -1,19 +0,0 @@
|
|||
# Maintainer: Anna Schumaker <anna@nowheycreamery.com>
|
||||
pkgname=emmental
|
||||
pkgver={MAJOR}.{MINOR}
|
||||
pkgrel=1
|
||||
pkgdesc='The cheesy music player'
|
||||
url='https://www.git.nowheycreamery.com/anna/emmental'
|
||||
arch=('any')
|
||||
license=('GPL3')
|
||||
depends=('python' 'python-gobject' 'python-mutagen' 'python-pyxdg' 'gtk4' 'gstreamer' 'gst-plugins-base')
|
||||
optdepends=('gst-plugins-good' 'gst-plugins-bad' 'gst-plugins-ugly')
|
||||
source=("https://git.nowheycreamery.com/anna/emmental/archive/emmental-$pkgver.tar.gz")
|
||||
sha256sums=({SHA256SUM})
|
||||
|
||||
package() {
|
||||
cd "$pkgname"
|
||||
make PREFIX="$pkgdir/usr" install
|
||||
sed -i "s|$pkgdir||" $pkgdir/usr/bin/emmental
|
||||
sed -i "s|$pkgdir||" $pkgdir/usr/share/applications/emmental.desktop
|
||||
}
|
|
@ -1,3 +0,0 @@
|
|||
#!/bin/bash
|
||||
|
||||
python {EMMENTAL_LIB}/emmental.py $*
|
|
@ -1,10 +0,0 @@
|
|||
[Desktop Entry]
|
||||
Type=Application
|
||||
Version=1.5
|
||||
Name=Emmental
|
||||
GenericName=Music Player
|
||||
Comment=Listen to your music
|
||||
Exec={EMMENTAL_BIN}/emmental
|
||||
Icon=emmental
|
||||
Terminal=false
|
||||
Categories=AudioVideo;Audio;
|
Binary file not shown.
Before Width: | Height: | Size: 28 KiB |
|
@ -1,60 +0,0 @@
|
|||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<!-- Created with Inkscape (http://www.inkscape.org/) -->
|
||||
|
||||
<svg
|
||||
width="512"
|
||||
height="512"
|
||||
viewBox="0 0 135.46666 135.46666"
|
||||
version="1.1"
|
||||
id="svg3294"
|
||||
inkscape:version="1.1 (c4e8f9ed74, 2021-05-24)"
|
||||
sodipodi:docname="emmental-favorites.svg"
|
||||
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
|
||||
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
|
||||
xmlns="http://www.w3.org/2000/svg"
|
||||
xmlns:svg="http://www.w3.org/2000/svg">
|
||||
<sodipodi:namedview
|
||||
id="namedview3296"
|
||||
pagecolor="#ffffff"
|
||||
bordercolor="#666666"
|
||||
borderopacity="1.0"
|
||||
inkscape:pageshadow="2"
|
||||
inkscape:pageopacity="0.0"
|
||||
inkscape:pagecheckerboard="0"
|
||||
inkscape:document-units="px"
|
||||
showgrid="false"
|
||||
width="512mm"
|
||||
units="px"
|
||||
inkscape:zoom="1"
|
||||
inkscape:cx="416.5"
|
||||
inkscape:cy="263.5"
|
||||
inkscape:window-width="1920"
|
||||
inkscape:window-height="1005"
|
||||
inkscape:window-x="0"
|
||||
inkscape:window-y="49"
|
||||
inkscape:window-maximized="1"
|
||||
inkscape:current-layer="layer2"
|
||||
showborder="true"
|
||||
borderlayer="false" />
|
||||
<defs
|
||||
id="defs3291">
|
||||
<linearGradient
|
||||
id="linearGradient3404"
|
||||
inkscape:swatch="solid">
|
||||
<stop
|
||||
style="stop-color:#ff0000;stop-opacity:1;"
|
||||
offset="0"
|
||||
id="stop3402" />
|
||||
</linearGradient>
|
||||
</defs>
|
||||
<g
|
||||
inkscape:groupmode="layer"
|
||||
id="layer2"
|
||||
inkscape:label="Layer 2"
|
||||
style="display:inline">
|
||||
<path
|
||||
id="rect928"
|
||||
style="mix-blend-mode:multiply;fill:#ff0000;fill-opacity:1;fill-rule:nonzero;stroke:#004600;stroke-width:1.13263;stroke-dasharray:0, 12.4589;stroke-opacity:1;paint-order:markers fill stroke"
|
||||
d="M 8.3491862,17.674821 A 48.298388,38.079963 55.167577 0 0 0.47527528,35.642866 48.298388,38.079963 55.167577 0 0 15.646486,80.346627 l 13.02172,14.124094 26.043443,28.248199 c 7.214034,7.82476 18.829408,7.82476 26.043442,0 L 106.79853,94.470721 119.82026,80.346627 A 38.079963,48.298388 34.832423 0 0 126.33111,16.788177 38.079963,48.298388 34.832423 0 0 67.73337,23.850231 48.298388,38.079963 55.167577 0 0 26.518717,7.3946768 48.298388,38.079963 55.167577 0 0 8.3491862,17.674821 Z" />
|
||||
</g>
|
||||
</svg>
|
Before Width: | Height: | Size: 2.2 KiB |
|
@ -1,50 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
import lib
|
||||
import pathlib
|
||||
import sqlite3
|
||||
|
||||
File = lib.data.emmental_data / "emmental.sqlite3"
|
||||
|
||||
Connection = sqlite3.connect(File, detect_types=sqlite3.PARSE_DECLTYPES)
|
||||
Connection.row_factory = sqlite3.Row
|
||||
|
||||
commit = Connection.commit
|
||||
execute = Connection.execute
|
||||
executemany = Connection.executemany
|
||||
|
||||
from . import artist
|
||||
from . import album
|
||||
from . import disc
|
||||
from . import genre
|
||||
from . import decade
|
||||
from . import year
|
||||
from . import library
|
||||
from . import track
|
||||
from . import playlist
|
||||
from . import state
|
||||
|
||||
def make_fake_track(trackno, length, title, path, lib="/a/b/c", art="Test Artist",
|
||||
alb="Test Album", disk=1, subtitle=None, yeer=2021):
|
||||
lib = library.Table.find(pathlib.Path(lib))
|
||||
art = artist.Table.find(art, art)
|
||||
alb = album.Table.find(art, alb)
|
||||
disk = disc.Table.find(alb, disk, subtitle)
|
||||
yeer = year.Table.find(yeer)
|
||||
return track.Table.insert(lib, art, alb, disk, yeer,trackno,
|
||||
length, title, pathlib.Path(path))
|
||||
|
||||
def reset():
|
||||
mods = [ artist, album, disc, genre, decade, year,
|
||||
library, track, playlist, state ]
|
||||
|
||||
for mod in mods: mod.Table.drop()
|
||||
for mod in mods: mod.Table.do_create()
|
||||
|
||||
genre.Map.reset()
|
||||
playlist.Map.reset()
|
||||
playlist.TempMap.reset()
|
||||
playlist.Table.create_default_playlists()
|
||||
|
||||
|
||||
if lib.version.TESTING: reset()
|
||||
playlist.Table.create_default_playlists()
|
74
db/album.py
74
db/album.py
|
@ -1,74 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
#
|
||||
# Table: albums
|
||||
# +---------+----------+-----------+------+------+
|
||||
# | albumid | artistid | plstateid | name | sort |
|
||||
# +---------+----------+-----------+------+------+
|
||||
#
|
||||
# Index: album_index
|
||||
# +-----------------------------+
|
||||
# | (artistid, name) -> albumid |
|
||||
# +-----------------------------+
|
||||
from gi.repository import GObject
|
||||
from . import artist
|
||||
from . import disc
|
||||
from . import execute
|
||||
from . import objects
|
||||
from . import state
|
||||
|
||||
class Album(objects.Tag):
|
||||
def do_get_column(self, column):
|
||||
return execute(f"SELECT {column} FROM albums "
|
||||
"WHERE albumid=?", [ self.rowid ])
|
||||
|
||||
@GObject.Property
|
||||
def artist(self):
|
||||
return artist.Artist(self.get_column("artistid"))
|
||||
|
||||
@GObject.Property
|
||||
def playlist_state(self):
|
||||
return state.PlaylistState(self.get_column("plstateid"))
|
||||
|
||||
def discs(self):
|
||||
cursor = execute(f"SELECT discid FROM discs "
|
||||
"WHERE albumid=?", [ self.rowid ])
|
||||
return [ disc.Disc(row["discid"]) for row in cursor.fetchall() ]
|
||||
|
||||
|
||||
class AlbumTable(objects.Table):
|
||||
def __init__(self):
|
||||
objects.Table.__init__(self, "albums", Album)
|
||||
|
||||
def do_create(self):
|
||||
execute("CREATE TABLE IF NOT EXISTS albums "
|
||||
"(albumid INTEGER PRIMARY KEY, "
|
||||
" artistid INTEGER, "
|
||||
" plstateid INTEGER NOT NULL, "
|
||||
" name TEXT, "
|
||||
" sort TEXT, "
|
||||
" FOREIGN KEY(artistid) REFERENCES artists(artistid), "
|
||||
" FOREIGN KEY(plstateid) REFERENCES playlist_states(plstateid), "
|
||||
" UNIQUE(artistid, name))")
|
||||
execute("CREATE INDEX IF NOT EXISTS artist_index "
|
||||
"ON albums(artistid, name)")
|
||||
|
||||
def do_insert(self, artist, name):
|
||||
plstate = state.Table.insert(random=False, loop=False)
|
||||
return execute("INSERT INTO albums (artistid, plstateid, name, sort) "
|
||||
"VALUES (?, ?, ?, ?)",
|
||||
[ int(artist), int(plstate), name, name.casefold() ])
|
||||
|
||||
def do_delete(self, album):
|
||||
state.Table.delete(album.playlist_state)
|
||||
return execute("DELETE FROM albums WHERE albumid=?", [ int(album) ])
|
||||
|
||||
def do_get(self, rowid):
|
||||
return execute("SELECT albumid FROM albums "
|
||||
"WHERE albumid=?", [ rowid ])
|
||||
|
||||
def do_lookup(self, artist, name):
|
||||
return execute("SELECT albumid FROM albums "
|
||||
"WHERE (artistid=? AND name=?)", [ int(artist), name ])
|
||||
|
||||
|
||||
Table = AlbumTable()
|
66
db/artist.py
66
db/artist.py
|
@ -1,66 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
#
|
||||
# Table: artists
|
||||
# +----------+-----------+------+------+
|
||||
# | artistid | plstateid | name | sort |
|
||||
# +----------+-----------+------+------+
|
||||
#
|
||||
# Index: artist_index
|
||||
# +------------------+
|
||||
# | name -> artistid |
|
||||
# +------------------+
|
||||
from gi.repository import GObject
|
||||
from . import album
|
||||
from . import execute
|
||||
from . import objects
|
||||
from . import state
|
||||
|
||||
class Artist(objects.Tag):
|
||||
def do_get_column(self, column):
|
||||
return execute(f"SELECT {column} FROM artists "
|
||||
"WHERE artistid=?", [ self.rowid ])
|
||||
|
||||
@GObject.Property
|
||||
def playlist_state(self):
|
||||
return state.PlaylistState(self.get_column("plstateid"))
|
||||
|
||||
def albums(self):
|
||||
cursor = execute(f"SELECT albumid FROM albums "
|
||||
"WHERE artistid=?", [ self.rowid ])
|
||||
return [ album.Album(row["albumid"]) for row in cursor.fetchall() ]
|
||||
|
||||
|
||||
class ArtistTable(objects.Table):
|
||||
def __init__(self):
|
||||
objects.Table.__init__(self, "artists", Artist)
|
||||
|
||||
def do_create(self):
|
||||
execute("CREATE TABLE IF NOT EXISTS artists "
|
||||
"(artistid INTEGER PRIMARY KEY, "
|
||||
" plstateid INTEGER NOT NULL, "
|
||||
" name TEXT UNIQUE, "
|
||||
" sort TEXT, "
|
||||
" FOREIGN KEY(plstateid) REFERENCES playlist_states(plstateid))")
|
||||
execute("CREATE INDEX IF NOT EXISTS artist_index "
|
||||
"ON artists(name)")
|
||||
|
||||
def do_insert(self, name, sort):
|
||||
plstate = state.Table.insert(random=False, loop=False)
|
||||
return execute("INSERT INTO artists (plstateid, name, sort) "
|
||||
"VALUES (?, ?, ?)",
|
||||
[ int(plstate), name, sort.casefold() ])
|
||||
|
||||
def do_delete(self, artist):
|
||||
state.Table.delete(artist.playlist_state)
|
||||
return execute("DELETE FROM artists WHERE artistid=?", [ int(artist) ])
|
||||
|
||||
def do_get(self, rowid):
|
||||
return execute("SELECT artistid FROM artists "
|
||||
"WHERE artistid=?", [ rowid ])
|
||||
|
||||
def do_lookup(self, name, sort=None):
|
||||
return execute("SELECT artistid FROM artists "
|
||||
"WHERE name=?", [ name ])
|
||||
|
||||
|
||||
Table = ArtistTable()
|
65
db/decade.py
65
db/decade.py
|
@ -1,65 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
#
|
||||
# Table: decades
|
||||
# +----------+-----------+--------+
|
||||
# | decadeid | plstateid | decade |
|
||||
# +----------+-----------+--------+
|
||||
from gi.repository import GObject
|
||||
from . import execute
|
||||
from . import objects
|
||||
from . import state
|
||||
from . import year
|
||||
|
||||
class Decade(objects.Row):
|
||||
def __gt__(self, rhs): return self.decade > rhs.decade
|
||||
def __lt__(self, rhs): return self.decade < rhs.decade
|
||||
def __str__(self): return f"{self.decade}s"
|
||||
|
||||
def do_get_column(self, column):
|
||||
return execute(f"SELECT {column} FROM decades "
|
||||
"WHERE decadeid=?", [ self.rowid ])
|
||||
|
||||
def years(self):
|
||||
cursor = execute(f"SELECT yearid FROM years "
|
||||
"WHERE decadeid=?", [ self.rowid ])
|
||||
return [ year.Year(row["yearid"]) for row in cursor.fetchall() ]
|
||||
|
||||
@GObject.Property
|
||||
def decade(self):
|
||||
return self.get_column("decade")
|
||||
|
||||
@GObject.Property
|
||||
def playlist_state(self):
|
||||
return state.PlaylistState(self.get_column("plstateid"))
|
||||
|
||||
|
||||
class DecadeTable(objects.Table):
|
||||
def __init__(self):
|
||||
objects.Table.__init__(self, "decades", Decade)
|
||||
|
||||
def do_create(self):
|
||||
execute("CREATE TABLE IF NOT EXISTS decades "
|
||||
"(decadeid INTEGER PRIMARY KEY, "
|
||||
" plstateid INTEGER NOT NULL, "
|
||||
" decade INTEGER UNIQUE, "
|
||||
" FOREIGN KEY(plstateid) REFERENCES playlist_states(plstateid))")
|
||||
|
||||
def do_insert(self, decade):
|
||||
plstate = state.Table.insert(random=False, loop=False)
|
||||
return execute("INSERT INTO decades (plstateid,decade) "
|
||||
"VALUES (?, ?)", [ int(plstate), decade ])
|
||||
|
||||
def do_delete(self, decade):
|
||||
state.Table.delete(decade.playlist_state)
|
||||
return execute("DELETE FROM decades WHERE decadeid=?", [ int(decade) ])
|
||||
|
||||
def do_get(self, rowid):
|
||||
return execute("SELECT decadeid FROM decades "
|
||||
"WHERE decadeid=?", [ rowid ])
|
||||
|
||||
def do_lookup(self, decade):
|
||||
return execute("SELECT decadeid FROM decades "
|
||||
"WHERE decade=?", [ decade ])
|
||||
|
||||
|
||||
Table = DecadeTable()
|
77
db/disc.py
77
db/disc.py
|
@ -1,77 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
#
|
||||
# Table: discs
|
||||
# +--------+---------+--------+----------+
|
||||
# | discid | albumid | number | subtitle |
|
||||
# +--------+---------+--------+----------+
|
||||
from gi.repository import GObject
|
||||
from . import album
|
||||
from . import execute
|
||||
from . import objects
|
||||
from . import state
|
||||
|
||||
class Disc(objects.Row):
|
||||
def __gt__(self, rhs): return self.number > rhs.number
|
||||
def __lt__(self, rhs): return self.number < rhs.number
|
||||
def __str__(self):
|
||||
if self.subtitle:
|
||||
return f"{str(self.album)}: {self.subtitle}"
|
||||
return f"{str(self.album)}"
|
||||
|
||||
def do_get_column(self, column):
|
||||
return execute(f"SELECT {column} FROM discs "
|
||||
"WHERE discid=?", [ self.rowid ])
|
||||
|
||||
@GObject.Property
|
||||
def album(self):
|
||||
return album.Album(self.get_column("albumid"))
|
||||
|
||||
@GObject.Property
|
||||
def number(self):
|
||||
return self.get_column("number")
|
||||
|
||||
@GObject.Property
|
||||
def playlist_state(self):
|
||||
return state.PlaylistState(self.get_column("plstateid"))
|
||||
|
||||
@GObject.Property
|
||||
def subtitle(self):
|
||||
return self.get_column("subtitle")
|
||||
|
||||
|
||||
class DiscTable(objects.Table):
|
||||
def __init__(self):
|
||||
objects.Table.__init__(self, "discs", Disc)
|
||||
|
||||
def do_create(self):
|
||||
execute("CREATE TABLE IF NOT EXISTS discs "
|
||||
"(discid INTEGER PRIMARY KEY, "
|
||||
" albumid INTEGER, "
|
||||
" plstateid INTEGER NOT NULL, "
|
||||
" number INTEGER, "
|
||||
" subtitle TEXT, "
|
||||
" FOREIGN KEY(albumid) REFERENCES albums(albumid), "
|
||||
" FOREIGN KEY(plstateid) REFERENCES playlist_states(plstateid), "
|
||||
" UNIQUE(albumid, number))")
|
||||
|
||||
def do_insert(self, album, number, subtitle):
|
||||
subtitle = subtitle if subtitle and len(subtitle) > 0 else None
|
||||
plstate = state.Table.insert(random=False, loop=False)
|
||||
return execute("INSERT INTO discs (albumid, plstateid, number, subtitle) "
|
||||
"VALUES (?, ?, ?, ?)",
|
||||
[ int(album), int(plstate), number, subtitle ])
|
||||
|
||||
def do_delete(self, disc):
|
||||
state.Table.delete(disc.playlist_state)
|
||||
return execute("DELETE FROM discs WHERE discid=?", [ int(disc) ])
|
||||
|
||||
def do_get(self, rowid):
|
||||
return execute("SELECT discid FROM discs "
|
||||
"WHERE discid=?", [ rowid ])
|
||||
|
||||
def do_lookup(self, album, number, subtitle=None):
|
||||
return execute("SELECT discid FROM discs "
|
||||
"WHERE (albumid=? AND number=?)", [ int(album), number ])
|
||||
|
||||
|
||||
Table = DiscTable()
|
101
db/genre.py
101
db/genre.py
|
@ -1,101 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
#
|
||||
# Table: genres
|
||||
# +---------+-----------+------+------+
|
||||
# | genreid | plstateid | name | sort |
|
||||
# +---------+-----------+------+------+
|
||||
#
|
||||
# Index: genre_index
|
||||
# +-----------------+
|
||||
# | name -> genreid |
|
||||
# +-----------------+
|
||||
#
|
||||
# Map: genre_map
|
||||
# +---------+---------+
|
||||
# | genreid | trackid |
|
||||
# +---------+---------+
|
||||
from gi.repository import GObject
|
||||
from . import execute
|
||||
from . import objects
|
||||
from . import state
|
||||
from . import track
|
||||
|
||||
class Genre(objects.Tag):
|
||||
def do_get_column(self, column):
|
||||
return execute(f"SELECT {column} FROM genres "
|
||||
"WHERE genreid=?", [ self.rowid ])
|
||||
|
||||
@GObject.Property
|
||||
def playlist_state(self):
|
||||
return state.PlaylistState(self.get_column("plstateid"))
|
||||
|
||||
|
||||
class GenreTable(objects.Table):
|
||||
def __init__(self):
|
||||
objects.Table.__init__(self, "genres", Genre)
|
||||
|
||||
def do_create(self):
|
||||
execute("CREATE TABLE IF NOT EXISTS genres "
|
||||
"(genreid INTEGER PRIMARY KEY, "
|
||||
" plstateid INTEGER NOT NULL, "
|
||||
" name TEXT UNIQUE, "
|
||||
" sort TEXT)")
|
||||
execute("CREATE INDEX IF NOT EXISTS genre_index "
|
||||
"ON genres(name)")
|
||||
|
||||
def do_insert(self, name):
|
||||
plstate = state.Table.insert(random=False, loop=False)
|
||||
return execute("INSERT INTO genres (plstateid, name, sort) "
|
||||
"VALUES (?, ?, ?)",
|
||||
[ int(plstate), name, name.casefold() ])
|
||||
|
||||
def do_delete(self, genre):
|
||||
state.Table.delete(genre.playlist_state)
|
||||
return execute("DELETE FROM genres WHERE genreid=?", [ int(genre) ])
|
||||
|
||||
def do_get(self, rowid):
|
||||
return execute("SELECT genreid FROM genres "
|
||||
"WHERE genreid=?", [ rowid ])
|
||||
|
||||
def do_lookup(self, name):
|
||||
return execute("SELECT genreid FROM genres "
|
||||
"WHERE name=?", [ name ])
|
||||
|
||||
|
||||
class GenreMap(objects.Map):
|
||||
def __init__(self):
|
||||
objects.Map.__init__(self, "genre_map", Genre, track.Track)
|
||||
self.lookup_tracks = self.lookup_rhs
|
||||
self.lookup_genres = self.lookup_lhs
|
||||
|
||||
def do_create(self):
|
||||
execute("CREATE TABLE IF NOT EXISTS genre_map "
|
||||
"(genreid INTEGER, "
|
||||
" trackid INTEGER, "
|
||||
" FOREIGN KEY(genreid) REFERENCES genres(genreid), "
|
||||
" FOREIGN KEY(trackid) REFERENCES tracks(trackid), "
|
||||
" UNIQUE(genreid, trackid))")
|
||||
|
||||
def do_insert(self, genre, track):
|
||||
execute("INSERT INTO genre_map (genreid, trackid) "
|
||||
"VALUES (?, ?)", [ int(genre), int(track) ])
|
||||
|
||||
def do_delete(self, genre, track):
|
||||
return execute("DELETE FROM genre_map WHERE genreid=? AND trackid=?",
|
||||
[ int(genre), int(track) ])
|
||||
|
||||
def do_lookup_rhs(self, genre):
|
||||
return execute("SELECT trackid FROM genre_map "
|
||||
"WHERE genreid=?", [ int(genre) ])
|
||||
|
||||
def do_lookup_lhs(self, track):
|
||||
return execute("SELECT genreid FROM genre_map "
|
||||
"WHERE trackid=?", [ int(track) ])
|
||||
|
||||
def delete_track(self, track):
|
||||
for genre in self.lookup_genres(track):
|
||||
self.delete(genre, track)
|
||||
|
||||
|
||||
Table = GenreTable()
|
||||
Map = GenreMap()
|
|
@ -1,85 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
#
|
||||
# Table: libraries
|
||||
# +-----------+-----------+---------+------+
|
||||
# | libraryid | plstateid | enabled | path |
|
||||
# +-----------+-----------+---------+------+
|
||||
import pathlib
|
||||
from gi.repository import GObject
|
||||
from . import commit
|
||||
from . import execute
|
||||
from . import objects
|
||||
from . import state
|
||||
from . import track
|
||||
|
||||
class Library(objects.Row):
|
||||
def __lt__(self, rhs): return self.path < rhs.path
|
||||
def __gt__(self, rhs): return self.path > rhs.path
|
||||
def __str__(self): return str(self.path)
|
||||
|
||||
def do_get_column(self, column):
|
||||
return execute(f"SELECT {column} FROM libraries "
|
||||
"WHERE libraryid=?", [ self.rowid ])
|
||||
|
||||
def tracks(self):
|
||||
cursor = execute(f"SELECT trackid FROM tracks "
|
||||
"WHERE libraryid=?", [ self.rowid ])
|
||||
return [ track.Track(row["trackid"]) for row in cursor.fetchall() ]
|
||||
|
||||
@GObject.Property
|
||||
def playlist_state(self):
|
||||
return state.PlaylistState(self.get_column("plstateid"))
|
||||
|
||||
@GObject.Property
|
||||
def path(self):
|
||||
return pathlib.Path(self.get_column("path"))
|
||||
|
||||
@GObject.Property(type=bool,default=False)
|
||||
def enabled(self):
|
||||
return bool(self.get_column("enabled"))
|
||||
|
||||
@enabled.setter
|
||||
def enabled(self, newval):
|
||||
execute("UPDATE libraries "
|
||||
"SET enabled=? "
|
||||
"WHERE libraryid=?", [ newval, self.rowid ])
|
||||
commit()
|
||||
|
||||
|
||||
class LibraryTable(objects.Table):
|
||||
def __init__(self):
|
||||
objects.Table.__init__(self, "libraries", Library)
|
||||
|
||||
def do_create(self):
|
||||
execute("CREATE TABLE IF NOT EXISTS libraries "
|
||||
"(libraryid INTEGER PRIMARY KEY, "
|
||||
" plstateid INTEGER NOT NULL, "
|
||||
" enabled INTEGER DEFAULT 1, "
|
||||
" path TEXT UNIQUE, "
|
||||
" FOREIGN KEY (plstateid) REFERENCES playlist_states(plstateid))")
|
||||
|
||||
def do_insert(self, path):
|
||||
plstate = state.Table.insert(random=False, loop=False)
|
||||
return execute("INSERT INTO libraries (plstateid, path) "
|
||||
"VALUES (?, ?)",
|
||||
[ int(plstate), str(path) ])
|
||||
|
||||
def do_delete(self, library):
|
||||
for t in library.tracks():
|
||||
track.Table.delete(t)
|
||||
state.Table.delete(library.playlist_state)
|
||||
return execute("DELETE FROM libraries WHERE libraryid=?", [ int(library) ])
|
||||
|
||||
def do_get(self, rowid):
|
||||
return execute("SELECT libraryid FROM libraries "
|
||||
"WHERE libraryid=?", [ rowid ])
|
||||
|
||||
def do_get_all(self):
|
||||
return execute("SELECT libraryid FROM libraries")
|
||||
|
||||
def do_lookup(self, path):
|
||||
return execute("SELECT libraryid FROM libraries "
|
||||
"WHERE path=?", [ str(path) ])
|
||||
|
||||
|
||||
Table = LibraryTable()
|
125
db/objects.py
125
db/objects.py
|
@ -1,125 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
import sqlite3
|
||||
from gi.repository import GObject
|
||||
from . import execute
|
||||
|
||||
class Row(GObject.GObject):
|
||||
def __init__(self, rowid):
|
||||
GObject.GObject.__init__(self)
|
||||
self.rowid = rowid
|
||||
|
||||
def __eq__(self, rhs): return self.rowid == rhs.rowid
|
||||
def __int__(self): return self.rowid
|
||||
|
||||
def do_get_column(self, column): raise NotImplementedError
|
||||
|
||||
def get_column(self, column):
|
||||
return self.do_get_column(column).fetchone()[column]
|
||||
|
||||
|
||||
class Tag(Row):
|
||||
def __gt__(self, rhs): return self.sort > rhs.sort
|
||||
def __lt__(self, rhs): return self.sort < rhs.sort
|
||||
def __str__(self): return self.name
|
||||
|
||||
@GObject.Property
|
||||
def name(self): return self.get_column("name")
|
||||
|
||||
@GObject.Property
|
||||
def sort(self): return self.get_column("sort")
|
||||
|
||||
|
||||
class Table(GObject.GObject):
|
||||
def __init__(self, name, type):
|
||||
GObject.GObject.__init__(self)
|
||||
self.table_name = name
|
||||
self.table_type = type
|
||||
|
||||
self.do_create()
|
||||
|
||||
def __getitem__(self, rowid): return self.get(rowid)
|
||||
|
||||
def do_create(self): raise NotImplementedError
|
||||
def do_delete(self, obj): raise NotImplementedError
|
||||
def do_insert(self, *args): raise NotImplementedError
|
||||
def do_get(self, rowid): raise NotImplementedError
|
||||
def do_get_all(self): raise NotImplementedError
|
||||
def do_lookup(self, *args): raise NotImplementedError
|
||||
|
||||
def insert(self, *args):
|
||||
cursor = self.do_insert(*args)
|
||||
object = self.table_type(cursor.lastrowid)
|
||||
self.emit("row-inserted", object)
|
||||
return object
|
||||
|
||||
def delete(self, obj):
|
||||
self.emit("row-deleted", obj)
|
||||
self.do_delete(obj)
|
||||
|
||||
def find(self, *args):
|
||||
if object := self.lookup(*args):
|
||||
return object
|
||||
return self.insert(*args)
|
||||
|
||||
def get(self, rowid):
|
||||
row = self.do_get(rowid).fetchone()
|
||||
return self.table_type(row[0]) if row else None
|
||||
|
||||
def get_all(self):
|
||||
rows = self.do_get_all().fetchall()
|
||||
return [ self.table_type(row[0]) for row in rows ]
|
||||
|
||||
def lookup(self, *args):
|
||||
row = self.do_lookup(*args).fetchone()
|
||||
return self.table_type(row[0]) if row else None
|
||||
|
||||
def drop(self):
|
||||
execute(f"DROP TABLE {self.table_name}")
|
||||
|
||||
@GObject.Signal(arg_types=(Row,))
|
||||
def row_inserted(self, row): pass
|
||||
|
||||
@GObject.Signal(arg_types=(Row,))
|
||||
def row_deleted(self, row): pass
|
||||
|
||||
|
||||
class Map(GObject.GObject):
|
||||
def __init__(self, name, lhs, rhs):
|
||||
GObject.GObject.__init__(self)
|
||||
self.map_name = name
|
||||
self.map_lhs = lhs
|
||||
self.map_rhs = rhs
|
||||
|
||||
self.do_create()
|
||||
|
||||
def do_create(self): raise NotImplementedError
|
||||
def do_insert(self, lhs, rhs): raise NotImplementedError
|
||||
def do_delete(self, lhs, rhs): raise NotImplementedError
|
||||
def do_lookup_rhs(self, lhs): raise NotImplementedError
|
||||
def do_lookup_lhs(self, rhs): raise NotImplementedError
|
||||
|
||||
def insert(self, lhs, rhs):
|
||||
cursor = self.do_insert(lhs, rhs)
|
||||
self.emit("row-inserted", lhs, rhs)
|
||||
|
||||
def delete(self, lhs, rhs):
|
||||
self.emit("row-deleted", lhs, rhs)
|
||||
self.do_delete(lhs, rhs)
|
||||
|
||||
def lookup_rhs(self, lhs):
|
||||
cursor = self.do_lookup_rhs(lhs)
|
||||
return [ self.map_rhs(row[0]) for row in cursor.fetchall() ]
|
||||
|
||||
def lookup_lhs(self, rhs):
|
||||
cursor = self.do_lookup_lhs(rhs)
|
||||
return [ self.map_lhs(row[0]) for row in cursor.fetchall() ]
|
||||
|
||||
def reset(self):
|
||||
execute(f"DROP TABLE {self.map_name}")
|
||||
self.do_create()
|
||||
|
||||
@GObject.Signal(arg_types=(Row,Row))
|
||||
def row_inserted(self, lhs, rhs): pass
|
||||
|
||||
@GObject.Signal(arg_types=(Row,Row))
|
||||
def row_deleted(self, lhs, rhs): pass
|
118
db/playlist.py
118
db/playlist.py
|
@ -1,118 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
#
|
||||
# Table: playlists
|
||||
# +------ ---+-----------+------+------+
|
||||
# | playlistid | plstateid | name | sort |
|
||||
# +-------- -+-----------+------+------+
|
||||
#
|
||||
# Index: playlist_index
|
||||
# +--------------------+
|
||||
# | name -> playlistid |
|
||||
# +--------------------+
|
||||
from gi.repository import GObject
|
||||
from . import execute
|
||||
from . import executemany
|
||||
from . import objects
|
||||
from . import state
|
||||
from . import track
|
||||
|
||||
Default = [ "Collection", "Favorites", "New Tracks",
|
||||
"Previous", "Queued Tracks" ]
|
||||
|
||||
|
||||
class Playlist(objects.Tag):
|
||||
def do_get_column(self, column):
|
||||
return execute(f"SELECT {column} FROM playlists "
|
||||
"WHERE playlistid=?", [ self.rowid ])
|
||||
|
||||
@GObject.Property
|
||||
def playlist_state(self):
|
||||
return state.PlaylistState(self.get_column("plstateid"))
|
||||
|
||||
|
||||
class PlaylistTable(objects.Table):
|
||||
def __init__(self):
|
||||
objects.Table.__init__(self, "playlists", Playlist)
|
||||
|
||||
def do_create(self):
|
||||
execute("CREATE TABLE IF NOT EXISTS playlists "
|
||||
"(playlistid INTEGER PRIMARY KEY, "
|
||||
" plstateid INTEGER NOT NULL, "
|
||||
" name TEXT UNIQUE, "
|
||||
" sort TEXT, "
|
||||
" FOREIGN KEY (plstateid) REFERENCES playlist_states(plstateid))")
|
||||
execute("CREATE INDEX IF NOT EXISTS playlist_index "
|
||||
"ON playlists(name)")
|
||||
|
||||
def do_insert(self, name, loop=False):
|
||||
plstate = state.Table.insert(random=False, loop=loop)
|
||||
return execute("INSERT INTO playlists (plstateid, name, sort) "
|
||||
"VALUES (?, ?, ?)", (int(plstate), name, name.casefold()))
|
||||
|
||||
def do_delete(self, playlist):
|
||||
Map.delete_playlist(playlist)
|
||||
TempMap.delete_playlist(playlist)
|
||||
return execute("DELETE FROM playlists WHERE playlistid=?", [ int(playlist) ])
|
||||
|
||||
def do_get(self, rowid):
|
||||
return execute("SELECT playlistid FROM playlists "
|
||||
"WHERE playlistid=?", [ rowid ])
|
||||
|
||||
def do_lookup(self, name):
|
||||
return execute("SELECT playlistid FROM playlists "
|
||||
"WHERE name=?", [ name ])
|
||||
|
||||
def create_default_playlists(self):
|
||||
for name in Default:
|
||||
if (plist := self.lookup(name)) != None:
|
||||
continue
|
||||
self.do_insert(name, name == "Collection")
|
||||
|
||||
|
||||
class PlaylistMap(objects.Map):
|
||||
def __init__(self, temp=False):
|
||||
name = "playlist_map" if temp==False else "temp_playlist_map"
|
||||
self.temporary = temp
|
||||
|
||||
objects.Map.__init__(self, name, Playlist, track.Track)
|
||||
self.lookup_tracks = self.lookup_rhs
|
||||
self.lookup_playlists = self.lookup_lhs
|
||||
|
||||
def do_create(self):
|
||||
temp = "" if self.temporary == False else "TEMPORARY"
|
||||
execute(f"CREATE {temp} TABLE IF NOT EXISTS {self.map_name} "
|
||||
"(playlistid INTEGER, "
|
||||
" trackid INTEGER, "
|
||||
" FOREIGN KEY(playlistid) REFERENCES playlists(playlistid), "
|
||||
" FOREIGN KEY(trackid) REFERENCES tracks(trackid), "
|
||||
" UNIQUE(playlistid, trackid))")
|
||||
|
||||
def do_insert(self, playlist, track):
|
||||
execute(f"INSERT INTO {self.map_name} (playlistid, trackid) "
|
||||
"VALUES (?, ?)", [ int(playlist), int(track) ])
|
||||
|
||||
def do_delete(self, playlist, track):
|
||||
return execute(f"DELETE FROM {self.map_name} "
|
||||
"WHERE playlistid=? AND trackid=?",
|
||||
[ int(playlist), int(track) ])
|
||||
|
||||
def do_lookup_rhs(self, playlist):
|
||||
return execute(f"SELECT trackid FROM {self.map_name} "
|
||||
"WHERE playlistid=?", [ int(playlist) ])
|
||||
|
||||
def do_lookup_lhs(self, track):
|
||||
return execute(f"SELECT playlistid FROM {self.map_name} "
|
||||
"WHERE trackid=?", [ int(track) ])
|
||||
|
||||
def delete_track(self, track):
|
||||
for playlist in self.lookup_playlists(track):
|
||||
self.delete(playlist, track)
|
||||
|
||||
def delete_playlist(self, playlist):
|
||||
for track in self.lookup_tracks(playlist):
|
||||
self.delete(playlist, track)
|
||||
|
||||
|
||||
Table = PlaylistTable()
|
||||
Map = PlaylistMap(temp=False)
|
||||
TempMap = PlaylistMap(temp=True)
|
80
db/state.py
80
db/state.py
|
@ -1,80 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
#
|
||||
# Table: playlist_states
|
||||
# +-----------+--------+------+---------+------+
|
||||
# | plstateid | random | loop | current | sort |
|
||||
# +-----------+--------+------+---------+------+
|
||||
from gi.repository import GObject
|
||||
from . import execute
|
||||
from . import objects
|
||||
|
||||
class PlaylistState(objects.Row):
|
||||
def do_get_column(self, column):
|
||||
return execute(f"SELECT {column} FROM playlist_states "
|
||||
"WHERE plstateid=?", [ self.rowid ])
|
||||
|
||||
@GObject.Property(type=bool,default=False)
|
||||
def random(self):
|
||||
return bool(self.get_column("random"))
|
||||
|
||||
@random.setter
|
||||
def random(self, newval):
|
||||
execute("UPDATE playlist_states SET random=? WHERE plstateid=?",
|
||||
[ newval, self.rowid ])
|
||||
|
||||
@GObject.Property(type=bool,default=False)
|
||||
def loop(self):
|
||||
return bool(self.get_column("loop"))
|
||||
|
||||
@loop.setter
|
||||
def loop(self, newval):
|
||||
execute("UPDATE playlist_states SET loop=? WHERE plstateid=?",
|
||||
[ newval, self.rowid ])
|
||||
|
||||
@GObject.Property(type=int)
|
||||
def current(self):
|
||||
return self.get_column("current")
|
||||
|
||||
@current.setter
|
||||
def current(self, newval):
|
||||
execute("UPDATE playlist_states SET current=? WHERE plstateid=?",
|
||||
[ newval, self.rowid ])
|
||||
|
||||
@GObject.Property(type=str)
|
||||
def sort(self):
|
||||
return self.get_column("sort")
|
||||
|
||||
@sort.setter
|
||||
def sort(self, newval):
|
||||
execute("UPDATE playlist_states SET sort=? WHERE plstateid=?",
|
||||
[ newval, self.rowid ])
|
||||
|
||||
|
||||
class PlaylistStateTable(objects.Table):
|
||||
def __init__(self):
|
||||
objects.Table.__init__(self, "playlist_states", PlaylistState)
|
||||
|
||||
def do_create(self):
|
||||
execute("CREATE TABLE IF NOT EXISTS playlist_states "
|
||||
"(plstateid INTEGER PRIMARY KEY, "
|
||||
" random INTEGER DEFAULT 0, "
|
||||
" loop INTEGER DEFAULT 0, "
|
||||
" current INTEGER DEFAULT -1, "
|
||||
" sort TEXT)")
|
||||
|
||||
def do_insert(self, random, loop):
|
||||
return execute("INSERT INTO playlist_states (random, loop, sort) "
|
||||
"VALUES (?, ?, ?)", (random, loop, ""))
|
||||
|
||||
def do_delete(self, state):
|
||||
return execute("DELETE FROM playlist_states WHERE plstateid=?", [ int(state) ])
|
||||
|
||||
def do_get(self, rowid):
|
||||
return execute("SELECT plstateid FROM playlist_states "
|
||||
"WHERE plstateid=?", [ rowid ])
|
||||
|
||||
def insert(self, random=False, loop=False):
|
||||
return super().insert(random, loop)
|
||||
|
||||
|
||||
Table = PlaylistStateTable()
|
|
@ -1,63 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
import db
|
||||
import sqlite3
|
||||
import unittest
|
||||
from gi.repository import GObject
|
||||
|
||||
|
||||
class TestAlbumTable(unittest.TestCase):
|
||||
def on_row_inserted(self, table, row):
|
||||
self.row_inserted = row
|
||||
|
||||
def setUp(self):
|
||||
db.reset()
|
||||
|
||||
def test_album_table_init(self):
|
||||
self.assertIsInstance(db.album.Table, db.album.AlbumTable)
|
||||
db.execute("SELECT albumid,artistid,plstateid,name,sort FROM albums")
|
||||
|
||||
def test_album_table_insert(self):
|
||||
db.album.Table.connect("row-inserted", self.on_row_inserted)
|
||||
|
||||
artist = db.artist.Table.insert("Test Artist", "Test Sort")
|
||||
album = db.album.Table.insert(artist, "Test Album")
|
||||
|
||||
self.assertIsInstance(album, db.album.Album)
|
||||
self.assertIsInstance(album, db.objects.Tag)
|
||||
self.assertEqual(self.row_inserted, album)
|
||||
|
||||
self.assertEqual(album.name, "Test Album")
|
||||
self.assertEqual(album.sort, "test album")
|
||||
self.assertEqual(album.get_property("artist"), artist)
|
||||
self.assertIsInstance(album.playlist_state, db.state.PlaylistState)
|
||||
|
||||
with self.assertRaises(sqlite3.IntegrityError):
|
||||
db.album.Table.insert(artist, "Test Album")
|
||||
|
||||
def test_album_table_delete(self):
|
||||
artist = db.artist.Table.find("Test Artist", "Test Sort")
|
||||
album = db.album.Table.find(artist, "Test Album")
|
||||
state = album.playlist_state
|
||||
|
||||
db.album.Table.delete(album)
|
||||
self.assertIsNone(db.album.Table.lookup(artist, "Test Album"))
|
||||
self.assertIsNone(db.state.Table.get(int(state)))
|
||||
|
||||
def test_album_table_get(self):
|
||||
artist = db.artist.Table.insert("Test Artist", "Test Sort")
|
||||
album = db.album.Table.insert(artist, "Test Album")
|
||||
self.assertEqual(db.album.Table.get(1), album)
|
||||
self.assertIsNone(db.album.Table.get(2))
|
||||
|
||||
def test_album_table_lookup(self):
|
||||
artist = db.artist.Table.insert("Test Artist", "Test Sort")
|
||||
album = db.album.Table.insert(artist, "Test Album")
|
||||
self.assertEqual(db.album.Table.lookup(artist, "Test Album"), album)
|
||||
self.assertIsNone(db.album.Table.lookup(artist, "none"))
|
||||
|
||||
def test_album_discs(self):
|
||||
artist = db.artist.Table.find("Test Artist", "Test Sort")
|
||||
album = db.album.Table.find(artist, "Test Album")
|
||||
disc1 = db.disc.Table.find(album, 1, None)
|
||||
disc2 = db.disc.Table.find(album, 2, None)
|
||||
self.assertEqual(album.discs(), [ disc1, disc2 ])
|
|
@ -1,60 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
import db
|
||||
import sqlite3
|
||||
import unittest
|
||||
from gi.repository import GObject
|
||||
|
||||
|
||||
class TestArtistTable(unittest.TestCase):
|
||||
def on_row_inserted(self, table, row):
|
||||
self.row_inserted = row
|
||||
|
||||
def on_row_deleted(self, table, row):
|
||||
self.row_deleted = row
|
||||
|
||||
def setUp(self):
|
||||
db.reset()
|
||||
|
||||
def test_artist_table_init(self):
|
||||
self.assertIsInstance(db.artist.Table, db.artist.ArtistTable)
|
||||
db.execute("SELECT artistid,plstateid,name,sort FROM artists")
|
||||
|
||||
def test_artist_table_insert(self):
|
||||
db.artist.Table.connect("row-inserted", self.on_row_inserted)
|
||||
|
||||
artist = db.artist.Table.insert("Test Artist", "Test Sort")
|
||||
self.assertIsInstance(artist, db.artist.Artist)
|
||||
self.assertIsInstance(artist, db.objects.Tag)
|
||||
self.assertEqual(self.row_inserted, artist)
|
||||
|
||||
self.assertEqual(artist.name, "Test Artist")
|
||||
self.assertEqual(artist.sort, "test sort")
|
||||
self.assertIsInstance(artist.playlist_state, db.state.PlaylistState)
|
||||
|
||||
with self.assertRaises(sqlite3.IntegrityError):
|
||||
db.artist.Table.insert("Test Artist", "Test Sort")
|
||||
|
||||
def test_artist_table_delete(self):
|
||||
artist = db.artist.Table.find("Test Artist", "Test Sort")
|
||||
state = artist.playlist_state
|
||||
db.artist.Table.connect("row-deleted", self.on_row_deleted)
|
||||
|
||||
db.artist.Table.delete(artist)
|
||||
self.assertIsNone(db.artist.Table.lookup("Test Artist"))
|
||||
self.assertIsNone(db.state.Table.get(int(state)))
|
||||
|
||||
def test_artist_table_get(self):
|
||||
artist = db.artist.Table.insert("Test Artist", "Test Sort")
|
||||
self.assertEqual(db.artist.Table.get(1), artist)
|
||||
self.assertIsNone(db.artist.Table.get(2))
|
||||
|
||||
def test_artist_table_lookup(self):
|
||||
artist = db.artist.Table.insert("Test Artist", "Test Sort")
|
||||
self.assertEqual(db.artist.Table.lookup("Test Artist"), artist)
|
||||
self.assertIsNone(db.artist.Table.lookup("none"))
|
||||
|
||||
def test_artist_albums(self):
|
||||
artist = db.artist.Table.find("Test Artist", "Test Sort")
|
||||
a = db.album.Table.find(artist, "A")
|
||||
b = db.album.Table.find(artist, "B")
|
||||
self.assertEqual(artist.albums(), [ a, b ])
|
|
@ -1,15 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
import db
|
||||
import lib
|
||||
import sqlite3
|
||||
import unittest
|
||||
|
||||
class TestDB(unittest.TestCase):
|
||||
def test_db_init(self):
|
||||
self.assertEqual(db.File, lib.data.emmental_data / "emmental.sqlite3")
|
||||
self.assertIsInstance(db.Connection, sqlite3.Connection)
|
||||
self.assertEqual(db.Connection.row_factory, sqlite3.Row)
|
||||
|
||||
self.assertEqual(db.commit, db.Connection.commit)
|
||||
self.assertEqual(db.execute, db.Connection.execute)
|
||||
self.assertEqual(db.executemany, db.Connection.executemany)
|
|
@ -1,61 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
import db
|
||||
import sqlite3
|
||||
import unittest
|
||||
from gi.repository import GObject
|
||||
|
||||
|
||||
class TestDecadeTable(unittest.TestCase):
|
||||
def setUp(self):
|
||||
db.reset()
|
||||
|
||||
def test_decade_table_init(self):
|
||||
self.assertIsInstance(db.decade.Table, db.decade.DecadeTable)
|
||||
db.execute("SELECT decadeid,plstateid,decade FROM decades")
|
||||
|
||||
def test_decade_table_insert(self):
|
||||
decade = db.decade.Table.insert(2020)
|
||||
|
||||
self.assertIsInstance(decade, db.decade.Decade)
|
||||
self.assertIsInstance(decade, db.objects.Row)
|
||||
|
||||
self.assertEqual(decade.decade, 2020)
|
||||
self.assertEqual(str(decade), "2020s")
|
||||
self.assertIsInstance(decade.playlist_state, db.state.PlaylistState)
|
||||
|
||||
with self.assertRaises(sqlite3.IntegrityError):
|
||||
db.decade.Table.insert(2020)
|
||||
|
||||
def test_decade_table_delete(self):
|
||||
decade = db.decade.Table.find(2020)
|
||||
state = decade.playlist_state
|
||||
|
||||
db.decade.Table.delete(decade)
|
||||
self.assertIsNone(db.decade.Table.lookup(2020))
|
||||
self.assertIsNone(db.state.Table.get(int(state)))
|
||||
|
||||
def test_decade_table_get(self):
|
||||
decade = db.decade.Table.insert(2020)
|
||||
self.assertEqual(db.decade.Table.get(1), decade)
|
||||
self.assertIsNone(db.decade.Table.get(2))
|
||||
|
||||
def test_decade_table_lookup(self):
|
||||
decade = db.decade.Table.insert(2020)
|
||||
self.assertEqual(db.decade.Table.lookup(2020), decade)
|
||||
self.assertIsNone(db.decade.Table.lookup(2021))
|
||||
|
||||
def test_decade_compare(self):
|
||||
d2010 = db.decade.Table.insert(2010)
|
||||
d2020 = db.decade.Table.insert(2020)
|
||||
|
||||
self.assertTrue(d2010 < d2020)
|
||||
self.assertTrue(d2020 > d2010)
|
||||
|
||||
self.assertFalse(d2010 > d2020)
|
||||
self.assertFalse(d2020 < d2010)
|
||||
|
||||
def test_decade_years(self):
|
||||
decade = db.decade.Table.insert(2020)
|
||||
y2020 = db.year.Table.insert(2020)
|
||||
y2021 = db.year.Table.insert(2021)
|
||||
self.assertEqual(decade.years(), [ y2020, y2021 ])
|
|
@ -1,75 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
import db
|
||||
import sqlite3
|
||||
import unittest
|
||||
from gi.repository import GObject
|
||||
|
||||
|
||||
class TestDiscTable(unittest.TestCase):
|
||||
def setUp(self):
|
||||
db.reset()
|
||||
|
||||
def test_disc_table_init(self):
|
||||
self.assertIsInstance(db.disc.Table, db.disc.DiscTable)
|
||||
db.execute("SELECT discid,albumid,plstateid,number,subtitle FROM discs")
|
||||
|
||||
def test_disc_table_insert(self):
|
||||
artist = db.artist.Table.insert("Test Artist", "Test Sort")
|
||||
album = db.album.Table.insert(artist, "Test Album")
|
||||
disc = db.disc.Table.insert(album, 1, "subtitle")
|
||||
|
||||
self.assertIsInstance(disc, db.disc.Disc)
|
||||
self.assertIsInstance(disc, db.objects.Row)
|
||||
|
||||
self.assertEqual(disc.album, album)
|
||||
self.assertEqual(disc.number, 1)
|
||||
self.assertEqual(disc.subtitle, "subtitle")
|
||||
self.assertEqual(str(disc), "Test Album: subtitle")
|
||||
self.assertIsInstance(disc.playlist_state, db.state.PlaylistState)
|
||||
|
||||
disc2 = db.disc.Table.insert(album, 2, None)
|
||||
self.assertEqual(disc2.subtitle, None)
|
||||
self.assertEqual(str(disc2), "Test Album")
|
||||
|
||||
disc3 = db.disc.Table.insert(album, 3, "")
|
||||
self.assertEqual(disc3.subtitle, None)
|
||||
self.assertEqual(str(disc3), "Test Album")
|
||||
|
||||
with self.assertRaises(sqlite3.IntegrityError):
|
||||
db.disc.Table.insert(album, 1, "subtitle")
|
||||
|
||||
def test_disc_table_delete(self):
|
||||
artist = db.artist.Table.find("Test Artist", "Test Sort")
|
||||
album = db.album.Table.find(artist, "Test Album")
|
||||
disc = db.disc.Table.find(album, 1, "subtitle")
|
||||
state = disc.playlist_state
|
||||
|
||||
db.disc.Table.delete(disc)
|
||||
self.assertIsNone(db.disc.Table.lookup(album, 1))
|
||||
self.assertIsNone(db.state.Table.get(int(state)))
|
||||
|
||||
def test_disc_table_get(self):
|
||||
artist = db.artist.Table.insert("Test Artist", "Test Sort")
|
||||
album = db.album.Table.insert(artist, "Test Album")
|
||||
disc = db.disc.Table.insert(album, 1, None)
|
||||
self.assertEqual(db.disc.Table.get(1), disc)
|
||||
self.assertIsNone(db.disc.Table.get(2))
|
||||
|
||||
def test_disc_table_lookup(self):
|
||||
artist = db.artist.Table.insert("Test Artist", "Test Sort")
|
||||
album = db.album.Table.insert(artist, "Test Album")
|
||||
disc = db.disc.Table.insert(album, 1, None)
|
||||
self.assertEqual(db.disc.Table.lookup(album, 1), disc)
|
||||
self.assertIsNone(db.disc.Table.lookup(album, "none"))
|
||||
|
||||
def test_disc_compare(self):
|
||||
artist = db.artist.Table.insert("Test Artist", "Test Sort")
|
||||
album = db.album.Table.insert(artist, "Test Album")
|
||||
disc1 = db.disc.Table.insert(album, 1, "subtitle")
|
||||
disc2 = db.disc.Table.insert(album, 2, "subtitle")
|
||||
|
||||
self.assertTrue(disc1 < disc2)
|
||||
self.assertTrue(disc2 > disc1)
|
||||
|
||||
self.assertFalse(disc1 > disc2)
|
||||
self.assertFalse(disc2 < disc1)
|
109
db/test_genre.py
109
db/test_genre.py
|
@ -1,109 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
import db
|
||||
import sqlite3
|
||||
import unittest
|
||||
from gi.repository import GObject
|
||||
|
||||
|
||||
class TestGenreTable(unittest.TestCase):
|
||||
def on_row_inserted(self, table, row):
|
||||
self.row_inserted = row
|
||||
|
||||
def setUp(self):
|
||||
db.reset()
|
||||
|
||||
def test_genre_table_init(self):
|
||||
self.assertIsInstance(db.genre.Table, db.genre.GenreTable)
|
||||
db.execute("SELECT genreid,plstateid,name,sort FROM genres")
|
||||
|
||||
def test_genre_table_insert(self):
|
||||
db.genre.Table.connect("row-inserted", self.on_row_inserted)
|
||||
|
||||
genre = db.genre.Table.insert("Test Genre")
|
||||
self.assertIsInstance(genre, db.genre.Genre)
|
||||
self.assertIsInstance(genre, db.objects.Tag)
|
||||
self.assertEqual(self.row_inserted, genre)
|
||||
|
||||
self.assertEqual(genre.name, "Test Genre")
|
||||
self.assertEqual(genre.sort, "test genre")
|
||||
self.assertIsInstance(genre.playlist_state, db.state.PlaylistState)
|
||||
|
||||
with self.assertRaises(sqlite3.IntegrityError):
|
||||
db.genre.Table.insert("Test Genre")
|
||||
|
||||
def test_genre_table_delete(self):
|
||||
genre = db.genre.Table.find("Test Genre")
|
||||
state = genre.playlist_state
|
||||
db.genre.Table.delete(genre)
|
||||
self.assertIsNone(db.genre.Table.lookup("Test Genre"))
|
||||
self.assertIsNone(db.state.Table.get(int(state)))
|
||||
|
||||
def test_genre_table_get(self):
|
||||
genre = db.genre.Table.insert("Test Genre")
|
||||
self.assertEqual(db.genre.Table.get(1), genre)
|
||||
self.assertIsNone(db.genre.Table.get(2))
|
||||
|
||||
def test_genre_table_lookup(self):
|
||||
genre = db.genre.Table.insert("Test Genre")
|
||||
self.assertEqual(db.genre.Table.lookup("Test Genre"), genre)
|
||||
self.assertIsNone(db.genre.Table.lookup("none"))
|
||||
|
||||
|
||||
class TestGenreMap(unittest.TestCase):
|
||||
def setUp(self):
|
||||
db.reset()
|
||||
|
||||
def test_genre_map_init(self):
|
||||
self.assertIsInstance(db.genre.Map, db.genre.GenreMap)
|
||||
self.assertEqual(db.genre.Map.map_lhs, db.genre.Genre)
|
||||
self.assertEqual(db.genre.Map.map_rhs, db.track.Track)
|
||||
db.execute("SELECT genreid,trackid FROM genre_map")
|
||||
|
||||
def test_genre_map_insert(self):
|
||||
track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
|
||||
genre = db.genre.Table.find("Test Genre")
|
||||
|
||||
db.genre.Map.insert(genre, track)
|
||||
with self.assertRaises(sqlite3.IntegrityError):
|
||||
db.genre.Map.insert(genre, track)
|
||||
|
||||
def test_genre_map_delete(self):
|
||||
track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
|
||||
genre = db.genre.Table.find("Test Genre")
|
||||
|
||||
db.genre.Map.insert(genre, track)
|
||||
db.genre.Map.delete(genre, track)
|
||||
self.assertEqual(db.genre.Map.lookup_tracks(genre), [ ])
|
||||
|
||||
def test_genre_map_lookup_tracks(self):
|
||||
track1 = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
|
||||
track2 = db.make_fake_track(2, 2.345, "Test Title 2", "/a/c.def")
|
||||
genre = db.genre.Table.find("Test Genre")
|
||||
|
||||
db.genre.Map.insert(genre, track1)
|
||||
db.genre.Map.insert(genre, track2)
|
||||
|
||||
lookup_res = db.genre.Map.lookup_tracks(genre)
|
||||
self.assertEqual(lookup_res, [ track1, track2 ])
|
||||
|
||||
def test_genre_map_lookup_genres(self):
|
||||
track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
|
||||
genre1 = db.genre.Table.find("Test Genre 1")
|
||||
genre2 = db.genre.Table.find("Test Genre 2")
|
||||
|
||||
db.genre.Map.insert(genre1, track)
|
||||
db.genre.Map.insert(genre2, track)
|
||||
|
||||
lookup_res = db.genre.Map.lookup_genres(track)
|
||||
self.assertEqual(lookup_res, [ genre1, genre2 ])
|
||||
|
||||
def test_genre_map_delete_track(self):
|
||||
track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
|
||||
genre1 = db.genre.Table.find("Test Genre 1")
|
||||
genre2 = db.genre.Table.find("Test Genre 2")
|
||||
|
||||
db.genre.Map.insert(genre1, track)
|
||||
db.genre.Map.insert(genre2, track)
|
||||
|
||||
db.genre.Map.delete_track(track)
|
||||
self.assertEqual(db.genre.Map.lookup_genres(track), [ ])
|
|
@ -1,79 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
import db
|
||||
import pathlib
|
||||
import sqlite3
|
||||
import unittest
|
||||
from gi.repository import GObject
|
||||
|
||||
|
||||
class TestLibraryTable(unittest.TestCase):
|
||||
def setUp(self):
|
||||
db.reset()
|
||||
|
||||
def test_library_table_init(self):
|
||||
self.assertIsInstance(db.library.Table, db.library.LibraryTable)
|
||||
db.execute("SELECT libraryid,plstateid,enabled,path FROM libraries")
|
||||
|
||||
def test_library_table_insert(self):
|
||||
library = db.library.Table.insert(pathlib.Path("/a/b/c"))
|
||||
self.assertIsInstance(library, db.library.Library)
|
||||
self.assertIsInstance(library, db.objects.Row)
|
||||
|
||||
self.assertEqual(library.path, pathlib.Path("/a/b/c"))
|
||||
self.assertEqual(str(library), "/a/b/c")
|
||||
self.assertTrue(library.enabled)
|
||||
self.assertIsInstance(library.playlist_state, db.state.PlaylistState)
|
||||
|
||||
with self.assertRaises(sqlite3.IntegrityError):
|
||||
db.library.Table.insert(pathlib.Path("/a/b/c"))
|
||||
|
||||
def test_library_table_delete(self):
|
||||
library = db.library.Table.find(pathlib.Path("/a/b/c"))
|
||||
state = library.playlist_state
|
||||
track = db.make_fake_track(1, 1.234, "Test 1", "/a/b/c/1.ext",
|
||||
lib=library.path)
|
||||
|
||||
db.library.Table.delete(library)
|
||||
self.assertIsNone(db.library.Table.lookup(pathlib.Path("/a/b/c")))
|
||||
self.assertIsNone(db.state.Table.get(int(state)))
|
||||
self.assertIsNone(db.track.Table.get(int(track)))
|
||||
|
||||
def test_library_table_get(self):
|
||||
library = db.library.Table.insert(pathlib.Path("/a/b/c"))
|
||||
self.assertEqual(db.library.Table.get(1), library)
|
||||
self.assertIsNone(db.library.Table.get(2))
|
||||
|
||||
def test_library_table_get_all(self):
|
||||
lib1 = db.library.Table.insert(pathlib.Path("/a/b/c"))
|
||||
lib2 = db.library.Table.insert(pathlib.Path("/d/e/f"))
|
||||
self.assertEqual(db.library.Table.get_all(), [ lib1, lib2 ])
|
||||
|
||||
def test_library_table_lookup(self):
|
||||
library = db.library.Table.insert(pathlib.Path("/a/b/c"))
|
||||
self.assertEqual(db.library.Table.lookup(pathlib.Path("/a/b/c")), library)
|
||||
self.assertIsNone(db.library.Table.lookup(pathlib.Path("/a/b/d")))
|
||||
|
||||
def test_library_compare(self):
|
||||
abc = db.library.Table.insert(pathlib.Path("/a/b/c"))
|
||||
efg = db.library.Table.insert(pathlib.Path("/e/f/g"))
|
||||
|
||||
self.assertTrue(abc < efg)
|
||||
self.assertTrue(efg > abc)
|
||||
|
||||
self.assertFalse(abc > efg)
|
||||
self.assertFalse(efg < abc)
|
||||
|
||||
def test_library_enabled(self):
|
||||
abc = db.library.Table.insert(pathlib.Path("/a/b/c"))
|
||||
self.assertTrue(abc.enabled)
|
||||
|
||||
abc.set_property("enabled", False)
|
||||
self.assertFalse(abc.enabled)
|
||||
|
||||
def test_library_tracks(self):
|
||||
library = db.library.Table.find(pathlib.Path("/a/b/c"))
|
||||
track1 = db.make_fake_track(1, 1.234, "Test 1", "/a/b/c/1.ext",
|
||||
lib=library.path)
|
||||
track2 = db.make_fake_track(2, 2.345, "Test 1", "/a/b/c/2.ext",
|
||||
lib=library.path)
|
||||
self.assertEqual(library.tracks(), [ track1, track2 ])
|
|
@ -1,169 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
import unittest
|
||||
from gi.repository import GObject
|
||||
from . import objects
|
||||
|
||||
class FakeCursor:
|
||||
def __init__(self, lastrowid): self.lastrowid = lastrowid
|
||||
def fetchone(self): return (self.lastrowid,) if self.lastrowid else None
|
||||
def fetchall(self): return [ (2,), (3,) ] if self.lastrowid else None
|
||||
|
||||
|
||||
class TestRow(unittest.TestCase):
|
||||
def test_row(self):
|
||||
row = objects.Row(1)
|
||||
self.assertEqual(row.rowid, 1)
|
||||
self.assertIsInstance(row, GObject.GObject)
|
||||
|
||||
self.assertEqual(int(row), 1)
|
||||
self.assertEqual(row, objects.Row(1))
|
||||
self.assertNotEqual(row, objects.Row(2))
|
||||
|
||||
with self.assertRaises(NotImplementedError):
|
||||
row.do_get_column("test")
|
||||
|
||||
|
||||
class FakeTagCursor:
|
||||
def __init__(self, col, text):
|
||||
self.col = col
|
||||
self.text = text
|
||||
def fetchone(self): return { self.col : self.text }
|
||||
|
||||
class FakeTag(objects.Tag):
|
||||
def __init__(self, tid, name, sort):
|
||||
objects.Tag.__init__(self, tid)
|
||||
self.fake_name = name
|
||||
self.fake_sort = sort
|
||||
|
||||
def do_get_column(self, column):
|
||||
if column == "name":
|
||||
return FakeTagCursor(column, self.fake_name)
|
||||
return FakeTagCursor(column, self.fake_sort)
|
||||
|
||||
class TestTag(unittest.TestCase):
|
||||
def test_tag(self):
|
||||
a = FakeTag(1, "A", "a")
|
||||
b = FakeTag(1, "B", "b")
|
||||
|
||||
self.assertIsInstance(a, objects.Tag)
|
||||
self.assertEqual(a.name, "A")
|
||||
self.assertEqual(a.sort, "a")
|
||||
self.assertEqual(str(a), "A")
|
||||
|
||||
self.assertEqual(a.get_property("name"), "A")
|
||||
self.assertEqual(a.get_property("sort"), "a")
|
||||
|
||||
self.assertTrue(a < b)
|
||||
self.assertTrue(b > a)
|
||||
|
||||
self.assertFalse(a > b)
|
||||
self.assertFalse(b < a)
|
||||
|
||||
|
||||
class FakeTable(objects.Table):
|
||||
def do_create(self): self.create_called = True
|
||||
def do_insert(self, insert, args): return FakeCursor(1)
|
||||
def do_delete(self, obj): self.delete_called = True
|
||||
def do_get(self, rowid): return FakeCursor(1)
|
||||
def do_get_all(self): return FakeCursor(1)
|
||||
def do_lookup(self, lookup, args):
|
||||
return FakeCursor(1) if lookup == "lookup" else FakeCursor(None)
|
||||
|
||||
class TestTable(unittest.TestCase):
|
||||
def on_row_inserted(self, table, row):
|
||||
self.row_inserted = row
|
||||
|
||||
def on_row_deleted(self, table, row):
|
||||
self.row_deleted = row
|
||||
|
||||
def test_table_errors(self):
|
||||
with self.assertRaises(NotImplementedError):
|
||||
table = objects.Table("table", objects.Row)
|
||||
with self.assertRaises(NotImplementedError):
|
||||
objects.Table.do_delete(None, objects.Row(1))
|
||||
with self.assertRaises(NotImplementedError):
|
||||
objects.Table.do_insert(None, "insert", "arguments")
|
||||
with self.assertRaises(NotImplementedError):
|
||||
objects.Table.do_get(None, 2)
|
||||
with self.assertRaises(NotImplementedError):
|
||||
objects.Table.do_get_all(None)
|
||||
with self.assertRaises(NotImplementedError):
|
||||
objects.Table.do_lookup(None, "lookup", "arguments")
|
||||
|
||||
def test_table(self):
|
||||
table = FakeTable("fake", objects.Row)
|
||||
table.connect("row-inserted", self.on_row_inserted)
|
||||
table.connect("row-deleted", self.on_row_deleted)
|
||||
|
||||
self.assertIsInstance(table, GObject.GObject)
|
||||
self.assertEqual(table.table_name, "fake")
|
||||
self.assertEqual(table.table_type, objects.Row)
|
||||
self.assertTrue(table.create_called)
|
||||
|
||||
self.assertEqual(table.insert("insert", "arguments"), objects.Row(1))
|
||||
self.assertEqual(self.row_inserted, objects.Row(1))
|
||||
|
||||
table.delete(objects.Row(1))
|
||||
self.assertEqual(self.row_deleted, objects.Row(1))
|
||||
self.assertTrue(table.delete_called)
|
||||
|
||||
self.assertEqual(table.get(1), objects.Row(1))
|
||||
self.assertEqual(table[1], objects.Row(1))
|
||||
|
||||
self.assertEqual(table.get_all(), [ objects.Row(2), objects.Row(3) ])
|
||||
|
||||
self.assertEqual(table.lookup("lookup", "arguments"), objects.Row(1))
|
||||
|
||||
self.row_inserted = None
|
||||
self.assertEqual(table.find("find", "arguments"), objects.Row(1))
|
||||
self.assertEqual(self.row_inserted, objects.Row(1))
|
||||
|
||||
|
||||
class FakeMap(objects.Map):
|
||||
def do_create(self): self.create_called = True
|
||||
def do_insert(self, lhs, rhs): return FakeCursor(1)
|
||||
def do_delete(self, lhs, rhs): return FakeCursor(1)
|
||||
def do_lookup_rhs(self, lhs): return FakeCursor(1)
|
||||
def do_lookup_lhs(self, lhs): return FakeCursor(1)
|
||||
|
||||
class TestMap(unittest.TestCase):
|
||||
def on_row_inserted(self, table, lhs, rhs):
|
||||
self.row_inserted = (lhs, rhs)
|
||||
|
||||
def on_row_deleted(self, table, lhs, rhs):
|
||||
self.row_deleted = (lhs, rhs)
|
||||
|
||||
def test_map_errors(self):
|
||||
with self.assertRaises(NotImplementedError):
|
||||
map = objects.Map("test_map", objects.Tag, objects.Row)
|
||||
with self.assertRaises(NotImplementedError):
|
||||
objects.Map.do_insert(None, True, False)
|
||||
with self.assertRaises(NotImplementedError):
|
||||
objects.Map.do_delete(None, True, False)
|
||||
with self.assertRaises(NotImplementedError):
|
||||
objects.Map.do_lookup_rhs(None, None)
|
||||
with self.assertRaises(NotImplementedError):
|
||||
objects.Map.do_lookup_lhs(None, None)
|
||||
|
||||
def test_map(self):
|
||||
map = FakeMap("test_map", objects.Row, objects.Row)
|
||||
map.connect("row-inserted", self.on_row_inserted)
|
||||
map.connect("row-deleted", self.on_row_deleted)
|
||||
|
||||
self.assertIsInstance(map, GObject.GObject)
|
||||
self.assertEqual(map.map_name, "test_map")
|
||||
self.assertEqual(map.map_lhs, objects.Row)
|
||||
self.assertEqual(map.map_rhs, objects.Row)
|
||||
self.assertTrue(map.create_called)
|
||||
|
||||
map.insert(objects.Row(1), objects.Row(2))
|
||||
self.assertEqual(self.row_inserted, (objects.Row(1), objects.Row(2)))
|
||||
|
||||
map.delete(objects.Row(1), objects.Row(2))
|
||||
self.assertEqual(self.row_deleted, (objects.Row(1), objects.Row(2)))
|
||||
|
||||
rhs_list = map.lookup_rhs(objects.Row(1))
|
||||
self.assertEqual(rhs_list, [ objects.Row(2), objects.Row(3) ])
|
||||
|
||||
lhs_list = map.lookup_lhs(objects.Row(2))
|
||||
self.assertEqual(lhs_list, [ objects.Row(2), objects.Row(3) ])
|
|
@ -1,151 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
import db
|
||||
import sqlite3
|
||||
import unittest
|
||||
from gi.repository import GObject
|
||||
|
||||
expected = [ (1, 1, "Collection", "collection", 0, 1),
|
||||
(2, 2, "Favorites", "favorites", 0, 0),
|
||||
(3, 3, "New Tracks", "new tracks", 0, 0),
|
||||
(4, 4, "Previous", "previous", 0, 0),
|
||||
(5, 5, "Queued Tracks", "queued tracks", 0, 0) ]
|
||||
|
||||
|
||||
class TestPlaylistTable(unittest.TestCase):
|
||||
def setUp(self):
|
||||
db.reset()
|
||||
|
||||
def test_playlist_table_init(self):
|
||||
self.assertIsInstance(db.playlist.Table, db.playlist.PlaylistTable)
|
||||
self.assertEqual(db.playlist.Default, [ "Collection", "Favorites", "New Tracks",
|
||||
"Previous", "Queued Tracks" ])
|
||||
|
||||
cur = db.execute("SELECT playlistid, "
|
||||
"playlists.plstateid, "
|
||||
"name, "
|
||||
"playlists.sort, "
|
||||
"random,loop "
|
||||
"FROM playlists "
|
||||
"JOIN playlist_states "
|
||||
"ON playlists.plstateid = playlist_states.plstateid")
|
||||
rows = cur.fetchall()
|
||||
self.assertEqual(tuple(rows[0]), expected[0])
|
||||
self.assertEqual(tuple(rows[1]), expected[1])
|
||||
self.assertEqual(tuple(rows[2]), expected[2])
|
||||
self.assertEqual(tuple(rows[3]), expected[3])
|
||||
self.assertEqual(tuple(rows[4]), expected[4])
|
||||
|
||||
def test_playlist_table_insert(self):
|
||||
playlist = db.playlist.Table.insert("Test Playlist")
|
||||
self.assertIsInstance(playlist, db.playlist.Playlist)
|
||||
self.assertIsInstance(playlist, db.objects.Tag)
|
||||
|
||||
self.assertEqual(playlist.name, "Test Playlist")
|
||||
self.assertEqual(playlist.sort, "test playlist")
|
||||
self.assertIsInstance(playlist.playlist_state, db.state.PlaylistState)
|
||||
|
||||
with self.assertRaises(sqlite3.IntegrityError):
|
||||
db.playlist.Table.insert("Test Playlist")
|
||||
|
||||
def test_playlist_table_delete(self):
|
||||
playlist = db.playlist.Table.find("Test Playlist")
|
||||
track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
|
||||
|
||||
db.playlist.Map.insert(playlist, track)
|
||||
db.playlist.TempMap.insert(playlist, track)
|
||||
db.playlist.Table.delete(playlist)
|
||||
|
||||
self.assertIsNone(db.playlist.Table.lookup("Test Playlist"))
|
||||
self.assertEqual(db.playlist.Map.lookup_playlists(track), [ ])
|
||||
self.assertEqual(db.playlist.TempMap.lookup_playlists(track), [ ])
|
||||
|
||||
def test_playlist_table_get(self):
|
||||
playlist = db.playlist.Playlist(1)
|
||||
self.assertEqual(db.playlist.Table.get(1), playlist)
|
||||
self.assertIsNone(db.playlist.Table.get(6))
|
||||
|
||||
def test_playlist_table_lookup(self):
|
||||
playlist = db.playlist.Table.insert("Test Playlist")
|
||||
self.assertEqual(db.playlist.Table.lookup("Test Playlist"), playlist)
|
||||
self.assertIsNone(db.playlist.Table.lookup("none"))
|
||||
|
||||
def test_playlist_create_default_playlists(self):
|
||||
db.playlist.Table.create_default_playlists()
|
||||
|
||||
|
||||
class TestPlaylistMap(unittest.TestCase):
|
||||
def setUp(self):
|
||||
db.reset()
|
||||
|
||||
def test_playlist_map_init(self):
|
||||
self.assertIsInstance(db.playlist.Map, db.playlist.PlaylistMap)
|
||||
self.assertIsInstance(db.playlist.TempMap, db.playlist.PlaylistMap)
|
||||
|
||||
self.assertEqual(db.playlist.Map.map_lhs, db.playlist.Playlist)
|
||||
self.assertEqual(db.playlist.Map.map_rhs, db.track.Track)
|
||||
|
||||
self.assertFalse(db.playlist.Map.temporary)
|
||||
self.assertTrue( db.playlist.TempMap.temporary)
|
||||
|
||||
db.execute("SELECT playlistid,trackid FROM playlist_map")
|
||||
db.execute("SELECT playlistid,trackid FROM temp_playlist_map")
|
||||
|
||||
def test_playlist_map_insert(self):
|
||||
track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
|
||||
collection = db.playlist.Table.find("Collection")
|
||||
|
||||
db.playlist.Map.insert(collection, track)
|
||||
with self.assertRaises(sqlite3.IntegrityError):
|
||||
db.playlist.Map.insert(collection, track)
|
||||
|
||||
def test_playlist_map_delete(self):
|
||||
track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
|
||||
playlist = db.playlist.Table.find("Test Playlist")
|
||||
|
||||
db.playlist.Map.insert(playlist, track)
|
||||
db.playlist.Map.delete(playlist, track)
|
||||
self.assertEqual(db.playlist.Map.lookup_tracks(playlist), [ ])
|
||||
|
||||
def test_playlist_map_lookup_tracks(self):
|
||||
track1 = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
|
||||
track2 = db.make_fake_track(2, 2.345, "Test Title 2", "/a/c.def")
|
||||
playlist = db.playlist.Table.find("Collection")
|
||||
|
||||
db.playlist.Map.insert(playlist, track1)
|
||||
db.playlist.Map.insert(playlist, track2)
|
||||
|
||||
lookup_res = db.playlist.Map.lookup_tracks(playlist)
|
||||
self.assertEqual(lookup_res, [ track1, track2 ])
|
||||
|
||||
def test_playlist_map_lookup_playlists(self):
|
||||
track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
|
||||
collection = db.playlist.Table.find("Collection")
|
||||
favorites = db.playlist.Table.find("Favorites")
|
||||
|
||||
db.playlist.Map.insert(collection, track)
|
||||
db.playlist.Map.insert(favorites, track)
|
||||
|
||||
lookup_res = db.playlist.Map.lookup_playlists(track)
|
||||
self.assertEqual(lookup_res, [ collection, favorites ])
|
||||
|
||||
def test_playlist_map_delete_track(self):
|
||||
track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
|
||||
collection = db.playlist.Table.find("Collection")
|
||||
favorites = db.playlist.Table.find("Favorites")
|
||||
|
||||
db.playlist.Map.insert(collection, track)
|
||||
db.playlist.Map.insert(favorites, track)
|
||||
|
||||
db.playlist.Map.delete_track(track)
|
||||
self.assertEqual(db.playlist.Map.lookup_playlists(track), [ ])
|
||||
|
||||
def test_playlist_map_delete_playlist(self):
|
||||
track1 = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
|
||||
track2 = db.make_fake_track(2, 2.345, "Test Title 2", "/a/c.def")
|
||||
playlist = db.playlist.Table.find("Collection")
|
||||
|
||||
db.playlist.Map.insert(playlist, track1)
|
||||
db.playlist.Map.insert(playlist, track2)
|
||||
|
||||
db.playlist.Map.delete_playlist(playlist)
|
||||
self.assertEqual(db.playlist.Map.lookup_tracks(playlist), [ ])
|
|
@ -1,53 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
import db
|
||||
import sqlite3
|
||||
import unittest
|
||||
from gi.repository import GObject
|
||||
|
||||
|
||||
class TestPlaylistStateTable(unittest.TestCase):
|
||||
def setUp(self):
|
||||
db.reset()
|
||||
|
||||
def test_playlist_state_table_init(self):
|
||||
self.assertIsInstance(db.state.Table, db.state.PlaylistStateTable)
|
||||
db.execute("SELECT plstateid,random,loop,current,sort "
|
||||
"FROM playlist_states")
|
||||
|
||||
def test_playlist_state_table_insert(self):
|
||||
state = db.state.Table.insert(False, False)
|
||||
|
||||
self.assertFalse(state.random)
|
||||
self.assertFalse(state.loop)
|
||||
self.assertEqual(state.current, -1)
|
||||
self.assertEqual(state.sort, "")
|
||||
|
||||
def test_playlist_state_table_delete(self):
|
||||
state = db.state.Table.insert(False, False)
|
||||
db.state.Table.delete(state)
|
||||
self.assertIsNone(db.state.Table.get(int(state)))
|
||||
|
||||
def test_playlist_state_table_get(self):
|
||||
state = db.state.Table.insert(False, False)
|
||||
self.assertEqual(db.state.Table.get(int(state)), state)
|
||||
self.assertIsNone(db.year.Table.get(int(state) + 1))
|
||||
|
||||
def test_playlist_state_table_lookup(self):
|
||||
state = db.state.Table.insert(False, False)
|
||||
with self.assertRaises(NotImplementedError):
|
||||
db.state.Table.lookup()
|
||||
|
||||
def test_playlist_state_properties(self):
|
||||
state = db.state.Table.insert(False, False)
|
||||
|
||||
state.random = True
|
||||
self.assertTrue(state.random)
|
||||
|
||||
state.loop = True
|
||||
self.assertTrue(state.loop)
|
||||
|
||||
state.current = 3
|
||||
self.assertEqual(state.current, 3)
|
||||
|
||||
state.sort = "album:True;artist:False"
|
||||
self.assertEqual(state.sort, "album:True;artist:False")
|
|
@ -1,91 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
import datetime
|
||||
import db
|
||||
import pathlib
|
||||
import sqlite3
|
||||
import unittest
|
||||
from gi.repository import GObject
|
||||
|
||||
|
||||
class TestTrackTable(unittest.TestCase):
|
||||
def setUp(self):
|
||||
db.reset()
|
||||
|
||||
def test_track_table_init(self):
|
||||
self.assertIsInstance(db.track.Table, db.track.TrackTable)
|
||||
db.execute("SELECT trackid,libraryid,artistid,albumid,discid,decadeid,yearid FROM tracks")
|
||||
db.execute("SELECT number,playcount,lastplayed,length,title,path FROM tracks")
|
||||
|
||||
def test_track_table_insert(self):
|
||||
library = db.library.Table.find(pathlib.Path("/a/b/c"))
|
||||
artist = db.artist.Table.find("Test Artist", "test artist")
|
||||
album = db.album.Table.find(artist, "Test Album")
|
||||
disc = db.disc.Table.find(album, 1, None)
|
||||
year = db.year.Table.find(2021)
|
||||
track = db.track.Table.insert(library, artist, album, disc, year,
|
||||
1, 1.234, "Test Title", pathlib.Path("/a/b/c/d.efg"))
|
||||
|
||||
self.assertIsInstance(track, db.track.Track)
|
||||
self.assertIsInstance(track, db.objects.Row)
|
||||
|
||||
self.assertEqual(track.library, library)
|
||||
self.assertEqual(track.artist, artist)
|
||||
self.assertEqual(track.album, album)
|
||||
self.assertEqual(track.disc, disc)
|
||||
self.assertEqual(track.decade, year.decade)
|
||||
self.assertEqual(track.year, year)
|
||||
|
||||
self.assertEqual(track.number, 1)
|
||||
self.assertEqual(track.playcount, 0)
|
||||
self.assertEqual(track.lastplayed, None)
|
||||
self.assertEqual(track.length, 1.234)
|
||||
self.assertEqual(track.title, "Test Title")
|
||||
self.assertEqual(track.path, pathlib.Path("/a/b/c/d.efg"))
|
||||
|
||||
with self.assertRaises(sqlite3.IntegrityError):
|
||||
db.track.Table.insert(library, artist, album, disc, year,
|
||||
1, 1.234, "Test Title", pathlib.Path("/a/b/c/d.efg"))
|
||||
|
||||
def test_track_table_delete(self):
|
||||
track = db.make_fake_track(1, 1.234, "Test Title", "/a/b/c/d.efg")
|
||||
genre = db.genre.Table.find("Test Genre")
|
||||
playlist = db.playlist.Table.find("Test Playlist")
|
||||
|
||||
db.genre.Map.insert(genre, track)
|
||||
db.playlist.Map.insert(playlist, track)
|
||||
db.playlist.TempMap.insert(playlist, track)
|
||||
db.track.Table.delete(track)
|
||||
|
||||
self.assertIsNone(db.track.Table.lookup(pathlib.Path("/a/b/c/d.efg")))
|
||||
self.assertEqual(db.genre.Map.lookup_tracks(genre), [ ])
|
||||
self.assertEqual(db.playlist.Map.lookup_tracks(playlist), [ ])
|
||||
self.assertEqual(db.playlist.TempMap.lookup_tracks(playlist), [ ])
|
||||
|
||||
def test_track_table_get(self):
|
||||
track = db.make_fake_track(1, 1.234, "Test Title", "/a/b/c/d.efg")
|
||||
self.assertEqual(db.track.Table.get(1), track)
|
||||
self.assertIsNone(db.track.Table.get(2))
|
||||
|
||||
def test_track_table_lookup(self):
|
||||
track = db.make_fake_track(1, 1.234, "Test Title", "/a/b/c/d.efg")
|
||||
self.assertEqual(db.track.Table.lookup(pathlib.Path("/a/b/c/d.efg")), track)
|
||||
self.assertIsNone(db.library.Table.lookup(pathlib.Path("/a/b/d/h.ijk")))
|
||||
|
||||
def test_track_table_find(self):
|
||||
with self.assertRaises(NotImplementedError):
|
||||
db.track.Table.find(pathlib.Path("/a/b/c/d.efg"))
|
||||
|
||||
def test_track_played(self):
|
||||
track = db.make_fake_track(1, 1.234, "Test Title", "/a/b/c/d.efg")
|
||||
now = datetime.datetime.now()
|
||||
yesterday = datetime.date.today() - datetime.timedelta(days=1)
|
||||
|
||||
track.played()
|
||||
self.assertEqual(track.playcount, 1)
|
||||
self.assertEqual(track.lastplayed.replace(microsecond=0),
|
||||
now.replace(microsecond=0))
|
||||
|
||||
track.last_played(4, yesterday)
|
||||
self.assertEqual(track.playcount, 4)
|
||||
self.assertEqual(track.lastplayed.replace(microsecond=0),
|
||||
datetime.datetime.combine(yesterday, datetime.time()))
|
|
@ -1,56 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
import db
|
||||
import sqlite3
|
||||
import unittest
|
||||
from gi.repository import GObject
|
||||
|
||||
|
||||
class TestYearTable(unittest.TestCase):
|
||||
def setUp(self):
|
||||
db.reset()
|
||||
|
||||
def test_year_table_init(self):
|
||||
self.assertIsInstance(db.year.Table, db.year.YearTable)
|
||||
db.execute("SELECT yearid,decadeid,plstateid,year FROM years")
|
||||
|
||||
def test_year_table_insert(self):
|
||||
decade = db.decade.Table.insert(2020)
|
||||
year = db.year.Table.insert(2021)
|
||||
|
||||
self.assertIsInstance(year, db.year.Year)
|
||||
self.assertIsInstance(year, db.objects.Row)
|
||||
|
||||
self.assertEqual(year.year, 2021)
|
||||
self.assertEqual(str(year), "2021")
|
||||
self.assertEqual(year.get_property("decade"), decade)
|
||||
self.assertIsInstance(year.playlist_state, db.state.PlaylistState)
|
||||
|
||||
with self.assertRaises(sqlite3.IntegrityError):
|
||||
db.year.Table.insert(2021)
|
||||
|
||||
def test_year_table_delete(self):
|
||||
year = db.year.Table.find(2021)
|
||||
state = year.playlist_state
|
||||
db.year.Table.delete(year)
|
||||
self.assertIsNone(db.year.Table.lookup(2021))
|
||||
self.assertIsNone(db.state.Table.get(int(state)))
|
||||
|
||||
def test_year_table_get(self):
|
||||
year = db.year.Table.insert(2021)
|
||||
self.assertEqual(db.year.Table.get(1), year)
|
||||
self.assertIsNone(db.year.Table.get(2))
|
||||
|
||||
def test_year_table_lookup(self):
|
||||
year = db.year.Table.insert(2021)
|
||||
self.assertEqual(db.year.Table.lookup(2021), year)
|
||||
self.assertIsNone(db.year.Table.lookup(2022))
|
||||
|
||||
def test_year_compare(self):
|
||||
y2021 = db.year.Table.insert(2021)
|
||||
y2022 = db.year.Table.insert(2022)
|
||||
|
||||
self.assertTrue(y2021 < y2022)
|
||||
self.assertTrue(y2022 > y2021)
|
||||
|
||||
self.assertFalse(y2021 > y2022)
|
||||
self.assertFalse(y2022 < y2021)
|
147
db/track.py
147
db/track.py
|
@ -1,147 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
#
|
||||
# Table: tracks
|
||||
# +---------+-----------+------------+---------+--------+--------+
|
||||
# | trackid | libraryid | artistid | albumid | discid | yearid |
|
||||
# +---------+-----------+------------+---------+--------+--------+
|
||||
# | number | playcount | lastplayed | length | title | path |
|
||||
# +---------+-----------+------------+---------+--------+--------|
|
||||
#
|
||||
# Index: track_index
|
||||
# +-----------------+
|
||||
# | path -> trackid |
|
||||
# +-----------------+
|
||||
import datetime
|
||||
import pathlib
|
||||
from gi.repository import GObject
|
||||
from . import artist
|
||||
from . import album
|
||||
from . import commit
|
||||
from . import decade
|
||||
from . import disc
|
||||
from . import execute
|
||||
from . import library
|
||||
from . import objects
|
||||
from . import year
|
||||
|
||||
class Track(objects.Row):
|
||||
def do_get_column(self, column):
|
||||
return execute(f"SELECT {column} FROM tracks "
|
||||
"WHERE trackid=?", [ self.rowid ])
|
||||
|
||||
@GObject.Property
|
||||
def library(self):
|
||||
return library.Library(self.get_column("libraryid"))
|
||||
|
||||
@GObject.Property
|
||||
def artist(self):
|
||||
return artist.Artist(self.get_column("artistid"))
|
||||
|
||||
@GObject.Property
|
||||
def album(self):
|
||||
return album.Album(self.get_column("albumid"))
|
||||
|
||||
@GObject.Property
|
||||
def disc(self):
|
||||
return disc.Disc(self.get_column("discid"))
|
||||
|
||||
@GObject.Property
|
||||
def decade(self):
|
||||
return decade.Decade(self.get_column("decadeid"))
|
||||
|
||||
@GObject.Property
|
||||
def year(self):
|
||||
return year.Year(self.get_column("yearid"))
|
||||
|
||||
@GObject.Property
|
||||
def number(self):
|
||||
return self.get_column("number")
|
||||
|
||||
@GObject.Property
|
||||
def playcount(self):
|
||||
return self.get_column("playcount")
|
||||
|
||||
@GObject.Property
|
||||
def lastplayed(self):
|
||||
return self.get_column("lastplayed")
|
||||
|
||||
@GObject.Property
|
||||
def length(self):
|
||||
return self.get_column("length")
|
||||
|
||||
@GObject.Property
|
||||
def title(self):
|
||||
return self.get_column("title")
|
||||
|
||||
@GObject.Property
|
||||
def path(self):
|
||||
return pathlib.Path(self.get_column("path"))
|
||||
|
||||
def played(self):
|
||||
execute("UPDATE tracks "
|
||||
"SET playcount=playcount+1, lastplayed=? "
|
||||
"WHERE trackid=?", [ datetime.datetime.now(), self.rowid ])
|
||||
commit()
|
||||
|
||||
def last_played(self, playcount, lastplayed):
|
||||
timestamp = datetime.datetime.combine(lastplayed, datetime.time())
|
||||
execute("UPDATE tracks "
|
||||
"SET playcount=?, lastplayed=? "
|
||||
"WHERE trackid=?", [ playcount, timestamp, self.rowid ])
|
||||
commit()
|
||||
|
||||
|
||||
class TrackTable(objects.Table):
|
||||
def __init__(self):
|
||||
objects.Table.__init__(self, "tracks", Track)
|
||||
|
||||
def do_create(self):
|
||||
execute("CREATE TABLE IF NOT EXISTS tracks "
|
||||
"(trackid INTEGER PRIMARY KEY, "
|
||||
" libraryid INTEGER, "
|
||||
" artistid INTEGER, "
|
||||
" albumid INTEGER, "
|
||||
" discid INTEGER, "
|
||||
" decadeid INTEGER, "
|
||||
" yearid INTEGER, "
|
||||
" number INTEGER, "
|
||||
" playcount INTEGER DEFAULT 0,"
|
||||
" lastplayed TIMESTAMP DEFAULT NULL, "
|
||||
" length REAL, "
|
||||
" title TEXT, "
|
||||
" path TEXT UNIQUE, "
|
||||
" FOREIGN KEY(libraryid) REFERENCES libraries(libraryid), "
|
||||
" FOREIGN KEY(artistid) REFERENCES artists(artistid), "
|
||||
" FOREIGN KEY(albumid) REFERENCES albums(albumid), "
|
||||
" FOREIGN KEY(discid) REFERENCES discs(discid), "
|
||||
" FOREIGN KEY(yearid) REFERENCES years(yearid))")
|
||||
execute("CREATE INDEX IF NOT EXISTS track_index ON tracks(path)")
|
||||
|
||||
def do_insert(self, library, artist, album, disc, year, number, length, title, path):
|
||||
return execute("INSERT INTO tracks (libraryid, artistid, albumid, discid, "
|
||||
"decadeid, yearid, number, length, title, path) "
|
||||
"VALUES (?,?,?,?,?,?,?,?,?,?)",
|
||||
[ int(library), int(artist), int(album), int(disc),
|
||||
int(year.decade), int(year), number, length, title, str(path) ])
|
||||
|
||||
def do_delete(self, track):
|
||||
from . import genre
|
||||
from . import playlist
|
||||
genre.Map.delete_track(track)
|
||||
playlist.Map.delete_track(track)
|
||||
playlist.TempMap.delete_track(track)
|
||||
return execute("DELETE FROM tracks WHERE trackid=?", [ int(track) ])
|
||||
|
||||
def do_get(self, rowid):
|
||||
return execute("SELECT trackid FROM tracks "
|
||||
"WHERE trackid=?", [ rowid ])
|
||||
|
||||
def do_lookup(self, path):
|
||||
return execute("SELECT trackid FROM tracks "
|
||||
"WHERE path=?", [ str(path) ])
|
||||
|
||||
def find(self, *args):
|
||||
raise NotImplementedError
|
||||
|
||||
|
||||
Table = TrackTable()
|
68
db/year.py
68
db/year.py
|
@ -1,68 +0,0 @@
|
|||
# Copyright 2021 (c) Anna Schumaker.
|
||||
#
|
||||
# Table: years
|
||||
# +--------+----------+-----------+------+
|
||||
# | yearid | decadeid | plstateid | year |
|
||||
# +--------+----------+-----------+------+
|
||||
from gi.repository import GObject
|
||||
from . import decade
|
||||
from . import execute
|
||||
from . import objects
|
||||
from . import state
|
||||
|
||||
class Year(objects.Row):
|
||||
def __gt__(self, rhs): return self.year > rhs.year
|
||||
def __lt__(self, rhs): return self.year < rhs.year
|
||||
def __str__(self): return str(self.year)
|
||||
|
||||
def do_get_column(self, column):
|
||||
return execute(f"SELECT {column} FROM years "
|
||||
"WHERE yearid=?", [ self.rowid ])
|
||||
|
||||
@GObject.Property
|
||||
def decade(self):
|
||||
return decade.Decade(self.get_column("decadeid"))
|
||||
|
||||
@GObject.Property
|
||||
def playlist_state(self):
|
||||
return state.PlaylistState(self.get_column("plstateid"))
|
||||
|
||||
@GObject.Property
|
||||
def year(self):
|
||||
return self.get_column("year")
|
||||
|
||||
|
||||
class YearTable(objects.Table):
|
||||
def __init__(self):
|
||||
objects.Table.__init__(self, "years", Year)
|
||||
|
||||
def do_create(self):
|
||||
execute("CREATE TABLE IF NOT EXISTS years "
|
||||
"(yearid INTEGER PRIMARY KEY, "
|
||||
" decadeid INTEGER, "
|
||||
" plstateid INTEGER NOT NULL, "
|
||||
" year INTEGER UNIQUE, "
|
||||
" FOREIGN KEY(decadeid) REFERENCES decades(decadeid), "
|
||||
" FOREIGN KEY(plstateid) REFERENCES playlist_states(plstateid))")
|
||||
|
||||
def do_insert(self, year):
|
||||
dec = decade.Table.find( (year // 10) * 10)
|
||||
plstate = state.Table.insert(random=False, loop=False)
|
||||
return execute("INSERT INTO years (decadeid, plstateid, year) "
|
||||
"VALUES (?, ?, ?)",
|
||||
[ int(dec), int(plstate), year ])
|
||||
|
||||
def do_delete(self, year):
|
||||
state.Table.delete(year.playlist_state)
|
||||
return execute("DELETE FROM years WHERE yearid=?", [ int(year) ])
|
||||
|
||||
def do_get(self, rowid):
|
||||
return execute("SELECT yearid FROM years "
|
||||
"WHERE yearid=?", [ rowid ])
|
||||
|
||||
def do_lookup(self, year):
|
||||
return execute("SELECT yearid FROM years "
|
||||
"WHERE year=?", [ year ])
|
||||
|
||||
|
||||
Table = YearTable()
|
17
emmental.py
17
emmental.py
|
@ -1,13 +1,8 @@
|
|||
#!/usr/bin/python
|
||||
# Copyright 2021 (c) Anna Schumaker.
|
||||
import gi
|
||||
gi.require_version('Gtk', '4.0')
|
||||
gi.require_version('Gst', '1.0')
|
||||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""The main Emmental application."""
|
||||
import sys
|
||||
import emmental
|
||||
|
||||
import lib
|
||||
import tagdb
|
||||
lib.settings.load()
|
||||
tagdb.load()
|
||||
|
||||
import ui
|
||||
ui.Application.run()
|
||||
if __name__ == "__main__":
|
||||
emmental.Application().run(sys.argv)
|
||||
|
|
|
@ -0,0 +1,343 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""Set up our Application."""
|
||||
import musicbrainzngs
|
||||
import pathlib
|
||||
from . import gsetup
|
||||
from . import action
|
||||
from . import audio
|
||||
from . import db
|
||||
from . import header
|
||||
from . import listenbrainz
|
||||
from . import mpris2
|
||||
from . import nowplaying
|
||||
from . import options
|
||||
from . import playlist
|
||||
from . import sidebar
|
||||
from . import tracklist
|
||||
from . import window
|
||||
from gi.repository import GObject
|
||||
from gi.repository import GLib
|
||||
from gi.repository import Gio
|
||||
from gi.repository import Adw
|
||||
|
||||
MAJOR_VERSION = 3
|
||||
MINOR_VERSION = 2
|
||||
MICRO_VERSION = 0
|
||||
|
||||
VERSION_NUMBER = f"{MAJOR_VERSION}.{MINOR_VERSION}.{MICRO_VERSION}"
|
||||
VERSION_STRING = f"Emmental {VERSION_NUMBER}{gsetup.DEBUG_STR}"
|
||||
|
||||
|
||||
class Application(Adw.Application):
|
||||
"""Our custom Adw.Application."""
|
||||
|
||||
db = GObject.Property(type=db.Connection)
|
||||
factory = GObject.Property(type=playlist.Factory)
|
||||
mpris = GObject.Property(type=mpris2.Connection)
|
||||
player = GObject.Property(type=audio.Player)
|
||||
lbrainz = GObject.Property(type=listenbrainz.ListenBrainz)
|
||||
win = GObject.Property(type=window.Window)
|
||||
|
||||
autopause = GObject.Property(type=int, default=-1, minimum=-1, maximum=99)
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize an Application."""
|
||||
super().__init__(application_id=gsetup.APPLICATION_ID,
|
||||
resource_base_path=gsetup.RESOURCE_PATH,
|
||||
flags=Gio.ApplicationFlags.HANDLES_OPEN)
|
||||
self.add_main_option_entries([options.Version])
|
||||
|
||||
def __add_accelerators(self, accels: list[action.ActionEntry]) -> None:
|
||||
for entry in accels:
|
||||
self.add_action(entry.action)
|
||||
self.set_accels_for_action(f"app.{entry.name}", entry.accels)
|
||||
|
||||
def __load_file(self, file: pathlib.Path,
|
||||
*, gapless: bool = False) -> None:
|
||||
self.__stop_current_track()
|
||||
if gapless:
|
||||
self.player.file = file
|
||||
else:
|
||||
self.player.stop()
|
||||
self.player.file = file
|
||||
self.player.play()
|
||||
|
||||
def __load_path(self, src: GObject.GObject, path: pathlib.Path) -> None:
|
||||
if (track := self.db.tracks.lookup(path=path)) is not None:
|
||||
self.__load_track(track)
|
||||
self.__load_file(path)
|
||||
|
||||
def __load_track(self, track: GObject.GObject, *, gapless: bool = False,
|
||||
rg_auto: str = "track", restart: bool = False) -> None:
|
||||
self.__load_file(track.path, gapless=gapless)
|
||||
if restart:
|
||||
track.restart()
|
||||
else:
|
||||
track.start()
|
||||
self.__set_replaygain(rg_auto=rg_auto)
|
||||
self.__on_jump()
|
||||
|
||||
def __pick_next_track(self, *, user: bool, gapless: bool = False) -> None:
|
||||
(track, rg_auto, restart) = self.factory.next_track(user=user)
|
||||
self.__load_track(track, gapless=gapless,
|
||||
rg_auto=rg_auto, restart=restart)
|
||||
|
||||
def __on_jump(self, nowplay: nowplaying.Card | None = None) -> None:
|
||||
"""Handle a jump event."""
|
||||
self.win.tracklist.scroll_to_track(self.db.tracks.current_track)
|
||||
|
||||
def __on_seek(self, nowplay: nowplaying.Card, newpos: float) -> None:
|
||||
"""Handle a seek event."""
|
||||
self.player.seek(newpos)
|
||||
self.mpris.player.seeked(newpos)
|
||||
|
||||
def __seek(self, player: mpris2.player.Player, offset: float) -> None:
|
||||
self.player.seek(self.player.position + offset)
|
||||
|
||||
def __set_position(self, player: mpris2.player.Player,
|
||||
trackid: str, position: float) -> None:
|
||||
self.player.seek(position)
|
||||
|
||||
def __set_replaygain(self, *args, rg_auto="track") -> None:
|
||||
enabled = self.db.settings["audio.replaygain.enabled"]
|
||||
mode = self.db.settings["audio.replaygain.mode"]
|
||||
mode = rg_auto if mode == "auto" else mode
|
||||
self.player.set_replaygain(enabled, mode)
|
||||
|
||||
def __stop_current_track(self) -> None:
|
||||
if self.db.tracks.current_track is not None:
|
||||
self.db.tracks.current_track.stop(self.player.playtime)
|
||||
|
||||
def __system_next(self, player: audio.Player, gapless: bool) -> None:
|
||||
self.player.pause_on_load = self.autopause == 0
|
||||
if self.autopause >= 0:
|
||||
self.autopause -= 1
|
||||
self.__pick_next_track(user=False, gapless=gapless)
|
||||
|
||||
def __user_next(self, *args) -> None:
|
||||
self.__pick_next_track(user=True)
|
||||
|
||||
def __user_previous(self, *args) -> None:
|
||||
self.__load_track(self.factory.previous_track(),
|
||||
rg_auto="track", restart=True)
|
||||
|
||||
def __track_requested(self, factory: playlist.Factory, track,
|
||||
rg_auto: str, restarted: bool) -> None:
|
||||
self.__load_track(track, rg_auto=rg_auto, restart=restarted)
|
||||
|
||||
def __tracks_table_loaded(self, track_table, param) -> None:
|
||||
if track_table.current_track is not None:
|
||||
self.player.file = track_table.current_track.path
|
||||
self.player.pause()
|
||||
track_table.current_track.start()
|
||||
self.__on_jump()
|
||||
|
||||
def build_header(self) -> header.Header:
|
||||
"""Build a new header instance."""
|
||||
hdr = header.Header(sql=self.db, title=VERSION_STRING)
|
||||
for prop in ["bg-enabled", "bg-volume", "volume"]:
|
||||
hdr.bind_property(prop, self.player, prop)
|
||||
hdr.bind_property("listenbrainz-token", self.lbrainz, "user-token")
|
||||
for (setting, property) in [("audio.volume", "volume"),
|
||||
("audio.background.enabled", "bg-enabled"),
|
||||
("audio.background.volume", "bg-volume"),
|
||||
("audio.replaygain.enabled", "rg-enabled"),
|
||||
("audio.replaygain.mode", "rg-mode"),
|
||||
("listenbrainz.token",
|
||||
"listenbrainz_token")]:
|
||||
self.db.settings.bind_setting(setting, hdr, property)
|
||||
|
||||
self.__add_accelerators(hdr.accelerators)
|
||||
|
||||
hdr.connect("notify::rg-enabled", self.__set_replaygain)
|
||||
hdr.connect("notify::rg-mode", self.__set_replaygain)
|
||||
hdr.connect("track-requested", self.__load_path)
|
||||
self.__set_replaygain()
|
||||
return hdr
|
||||
|
||||
def build_now_playing(self) -> nowplaying.Card:
|
||||
"""Build a new now playing card."""
|
||||
playing = nowplaying.Card()
|
||||
playing.bind_property("autopause", self, "autopause",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
for prop in ["title", "album", "artist", "album-artist", "playing",
|
||||
"position", "duration", "artwork", "have-track"]:
|
||||
self.player.bind_property(prop, playing, prop)
|
||||
self.db.tracks.bind_property("have-current-track",
|
||||
playing, "have-db-track")
|
||||
self.db.tracks.bind_property("current-favorite", playing, "favorite",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
self.factory.bind_property("can-go-next", playing, "have-next")
|
||||
self.factory.bind_property("can-go-previous", playing, "have-previous")
|
||||
self.db.settings.bind_setting("now-playing.prefer-artist",
|
||||
playing, "prefer-artist")
|
||||
|
||||
self.__add_accelerators(playing.accelerators)
|
||||
|
||||
playing.connect("jump", self.__on_jump)
|
||||
playing.connect("play", self.player.play)
|
||||
playing.connect("pause", self.player.pause)
|
||||
playing.connect("seek", self.__on_seek)
|
||||
playing.connect("next", self.__user_next)
|
||||
playing.connect("previous", self.__user_previous)
|
||||
return playing
|
||||
|
||||
def build_sidebar(self) -> sidebar.Card:
|
||||
"""Build a new sidebar card."""
|
||||
side_bar = sidebar.Card(sql=self.db)
|
||||
self.db.settings.bind_setting("sidebar.artists.show-all", side_bar,
|
||||
"show-all-artists")
|
||||
self.__add_accelerators(side_bar.accelerators)
|
||||
return side_bar
|
||||
|
||||
def build_tracklist(self) -> tracklist.Card:
|
||||
"""Build a new tracklist card."""
|
||||
track_list = tracklist.Card(sql=self.db)
|
||||
for column in track_list.columns:
|
||||
name = column.get_title().lower().replace(" ", "-")
|
||||
self.db.settings.bind_setting(f"tracklist.{name}.size",
|
||||
column, "fixed-width")
|
||||
self.db.settings.bind_setting(f"tracklist.{name}.visible",
|
||||
column, "visible")
|
||||
self.factory.bind_property("visible-playlist", track_list, "playlist")
|
||||
|
||||
self.__add_accelerators(track_list.accelerators)
|
||||
return track_list
|
||||
|
||||
def build_window(self) -> window.Window:
|
||||
"""Build a new window instance."""
|
||||
win = window.Window(VERSION_STRING,
|
||||
header=self.build_header(),
|
||||
now_playing=self.build_now_playing(),
|
||||
sidebar=self.build_sidebar(),
|
||||
tracklist=self.build_tracklist())
|
||||
win.bind_property("show-sidebar", win.header, "show-sidebar",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
win.bind_property("user-editing", win.now_playing, "editing")
|
||||
|
||||
for (setting, property) in [("window.width", "default-width"),
|
||||
("window.height", "default-height"),
|
||||
("now-playing.size", "now-playing-size"),
|
||||
("sidebar.show", "show-sidebar")]:
|
||||
self.db.settings.bind_setting(setting, win, property)
|
||||
|
||||
self.__add_accelerators(win.accelerators)
|
||||
return win
|
||||
|
||||
def connect_mpris2(self) -> None:
|
||||
"""Connect the mpris2 properties and functions."""
|
||||
self.mpris.app.link_property("Fullscreen", self.win, "fullscreened")
|
||||
self.mpris.app.connect("Raise", self.win.present)
|
||||
self.mpris.app.connect("Quit", self.win.close)
|
||||
|
||||
for tag in ["artist", "album", "album-artist", "album-disc-number",
|
||||
"title", "track-number", "duration", "file", "artwork"]:
|
||||
self.player.bind_property(tag, self.mpris.player, tag)
|
||||
for (prop, mpris_prop) in [("have-track", "CanPlay"),
|
||||
("have-track", "CanPause"),
|
||||
("have-track", "CanSeek"),
|
||||
("status", "PlaybackStatus"),
|
||||
("position", "Position")]:
|
||||
self.player.bind_property(prop, self.mpris.player, mpris_prop)
|
||||
for (prop, mpris_prop) in [("active-shuffle", "Shuffle"),
|
||||
("active-loop", "LoopStatus")]:
|
||||
self.factory.bind_property(prop, self.mpris.player, mpris_prop,
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
for (prop, mpris_prop) in [("can-go-next", "CanGoNext"),
|
||||
("can-go-previous", "CanGoPrevious")]:
|
||||
self.factory.bind_property(prop, self.mpris.player, mpris_prop)
|
||||
self.mpris.player.link_property("Volume", self.win.header, "volume")
|
||||
|
||||
self.mpris.player.connect("OpenPath", self.__load_path)
|
||||
self.mpris.player.connect("Next", self.__user_next)
|
||||
self.mpris.player.connect("Previous", self.__user_previous)
|
||||
self.mpris.player.connect("Pause", self.player.pause)
|
||||
self.mpris.player.connect("Play", self.player.play)
|
||||
self.mpris.player.connect("PlayPause", self.player.play_pause)
|
||||
self.mpris.player.connect("Seek", self.__seek)
|
||||
self.mpris.player.connect("SetPosition", self.__set_position)
|
||||
self.mpris.player.connect("Stop", self.player.stop)
|
||||
|
||||
def connect_listenbrainz(self) -> None:
|
||||
"""Connect the listenbrainz client."""
|
||||
self.db.tracks.bind_property("current-track",
|
||||
self.lbrainz, "now-playing")
|
||||
self.lbrainz.bind_property("valid-token", self.win.header,
|
||||
"listenbrainz-token-valid")
|
||||
|
||||
self.db.tracks.connect("track-played", self.lbrainz.submit_listens)
|
||||
|
||||
def connect_playlist_factory(self) -> None:
|
||||
"""Connect the playlist factory properties."""
|
||||
self.db.playlists.bind_property("previous",
|
||||
self.factory, "db-previous")
|
||||
self.win.sidebar.bind_property("selected-playlist",
|
||||
self.factory, "db-visible")
|
||||
self.factory.connect("track-requested", self.__track_requested)
|
||||
|
||||
def connect_player(self) -> None:
|
||||
"""Connect the audio.Player."""
|
||||
self.player.connect("about-to-finish", self.__system_next, True)
|
||||
self.player.connect("eos", self.__system_next, False)
|
||||
|
||||
def do_handle_local_options(self, opts: GLib.VariantDict) -> int:
|
||||
"""Handle any command line options."""
|
||||
if opts.contains("version"):
|
||||
print(VERSION_STRING)
|
||||
gsetup.print_env()
|
||||
return 0
|
||||
return -1
|
||||
|
||||
def do_startup(self) -> None:
|
||||
"""Handle the Adw.Application::startup signal."""
|
||||
Adw.Application.do_startup(self)
|
||||
self.db = db.Connection()
|
||||
self.mpris = mpris2.Connection()
|
||||
self.lbrainz = listenbrainz.ListenBrainz(self.db)
|
||||
self.factory = playlist.Factory(self.db)
|
||||
self.player = audio.Player()
|
||||
|
||||
gsetup.add_style()
|
||||
musicbrainzngs.set_useragent(f"emmental{gsetup.DEBUG_STR}",
|
||||
VERSION_NUMBER)
|
||||
self.db.tracks.connect("notify::loaded", self.__tracks_table_loaded)
|
||||
self.db.load()
|
||||
|
||||
self.win = self.build_window()
|
||||
self.add_window(self.win)
|
||||
self.connect_mpris2()
|
||||
self.connect_listenbrainz()
|
||||
self.connect_playlist_factory()
|
||||
self.connect_player()
|
||||
|
||||
def do_activate(self) -> None:
|
||||
"""Handle the Adw.Application::activate signal."""
|
||||
Adw.Application.do_activate(self)
|
||||
self.win.present()
|
||||
|
||||
def do_open(self, files: list, n_files: int, hint: str) -> None:
|
||||
"""Play an audio file passed from the command line."""
|
||||
if n_files > 0:
|
||||
path = pathlib.Path(files[0].get_path())
|
||||
self.db.tracks.mark_path_active(path)
|
||||
self.__load_path(None, path)
|
||||
self.activate()
|
||||
|
||||
def do_shutdown(self) -> None:
|
||||
"""Handle the Adw.Application::shutdown signal."""
|
||||
Adw.Application.do_shutdown(self)
|
||||
if self.player is not None:
|
||||
self.player.shutdown()
|
||||
self.player = None
|
||||
if self.win is not None:
|
||||
self.win.close()
|
||||
self.win = None
|
||||
if self.lbrainz is not None:
|
||||
self.lbrainz.stop()
|
||||
self.lbrainz = None
|
||||
if self.mpris is not None:
|
||||
self.mpris.disconnect()
|
||||
self.mpris = None
|
||||
if self.db is not None:
|
||||
self.db.close()
|
||||
self.db = None
|
|
@ -0,0 +1,39 @@
|
|||
# Copyright 2023 (c) Anna Schumaker.
|
||||
"""A custom ActionEntry that works in Python."""
|
||||
from gi.repository import GObject
|
||||
from gi.repository import Gio
|
||||
from gi.repository import Gtk
|
||||
|
||||
|
||||
class ActionEntry(GObject.GObject):
|
||||
"""Our own AcitionEntry class to make accelerators easier."""
|
||||
|
||||
enabled = GObject.Property(type=bool, default=True)
|
||||
|
||||
def __init__(self, name: str, func: callable, *accels: tuple[str],
|
||||
enabled: tuple[GObject.GObject, str] | None = None):
|
||||
"""Initialize an ActionEntry."""
|
||||
super().__init__()
|
||||
|
||||
for accel in accels:
|
||||
if not Gtk.accelerator_parse(accel)[0]:
|
||||
raise ValueError
|
||||
|
||||
self.accels = list(accels)
|
||||
self.func = func
|
||||
|
||||
if enabled is not None:
|
||||
self.enabled = enabled[0].get_property(enabled[1])
|
||||
enabled[0].bind_property(enabled[1], self, "enabled")
|
||||
|
||||
self.action = Gio.SimpleAction(name=name, enabled=self.enabled)
|
||||
self.action.connect("activate", self.__activate)
|
||||
self.bind_property("enabled", self.action, "enabled")
|
||||
|
||||
def __activate(self, action: Gio.SimpleAction, param) -> None:
|
||||
self.func()
|
||||
|
||||
@property
|
||||
def name(self) -> str:
|
||||
"""Get then name of this ActionEntry."""
|
||||
return self.action.get_name()
|
|
@ -0,0 +1,48 @@
|
|||
# Copyright 2023 (c) Anna Schumaker.
|
||||
"""Functions for configuring a callback at a specific time."""
|
||||
import datetime
|
||||
import math
|
||||
from gi.repository import GLib
|
||||
|
||||
_GSOURCE_MAPPING = dict()
|
||||
_NEXT_ALARM_ID = 1
|
||||
|
||||
|
||||
def _calc_seconds(time: datetime.time) -> int:
|
||||
"""Calculate the number of seconds until the given time."""
|
||||
now = datetime.datetime.now()
|
||||
then = datetime.datetime.combine(now.date(), time)
|
||||
|
||||
if now >= then:
|
||||
then += datetime.timedelta(days=1)
|
||||
|
||||
return math.ceil((then - now).total_seconds())
|
||||
|
||||
|
||||
def __set_alarm(time: datetime.time, func: callable, alarm_id: int) -> None:
|
||||
gsrcid = GLib.timeout_add_seconds(_calc_seconds(time), _do_alarm,
|
||||
time, func, alarm_id)
|
||||
_GSOURCE_MAPPING[alarm_id] = gsrcid
|
||||
return alarm_id
|
||||
|
||||
|
||||
def _do_alarm(time: datetime.time, func: callable, alarm_id: int) -> bool:
|
||||
"""Run an alarm callback."""
|
||||
func()
|
||||
__set_alarm(time, func, alarm_id)
|
||||
return GLib.SOURCE_REMOVE
|
||||
|
||||
|
||||
def set_alarm(time: datetime.time, func: callable) -> int:
|
||||
"""Register a callback to be called at a specific time."""
|
||||
global _NEXT_ALARM_ID
|
||||
|
||||
res = __set_alarm(time, func, _NEXT_ALARM_ID)
|
||||
_NEXT_ALARM_ID += 1
|
||||
return res
|
||||
|
||||
|
||||
def cancel_alarm(alarm_id: int) -> None:
|
||||
"""Cancel an alarm."""
|
||||
GLib.source_remove(_GSOURCE_MAPPING[alarm_id])
|
||||
del _GSOURCE_MAPPING[alarm_id]
|
|
@ -0,0 +1,238 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""A custom GObject managing a GStreamer playbin."""
|
||||
import pathlib
|
||||
from gi.repository import GObject
|
||||
from gi.repository import GLib
|
||||
from gi.repository import Gst
|
||||
from . import filter
|
||||
from .. import path
|
||||
from .. import tmpdir
|
||||
|
||||
|
||||
UPDATE_INTERVAL = 100
|
||||
SEEK_FLAGS = Gst.SeekFlags.FLUSH | Gst.SeekFlags.KEY_UNIT
|
||||
|
||||
|
||||
class Player(GObject.GObject):
|
||||
"""Wraps a GStreamer Playbin with an interface for our application."""
|
||||
|
||||
artist = GObject.Property(type=str)
|
||||
album = GObject.Property(type=str)
|
||||
album_artist = GObject.Property(type=str)
|
||||
album_disc_number = GObject.Property(type=int)
|
||||
title = GObject.Property(type=str)
|
||||
track_number = GObject.Property(type=int)
|
||||
position = GObject.Property(type=float, default=0)
|
||||
duration = GObject.Property(type=float, default=0)
|
||||
volume = GObject.Property(type=float, default=1.0)
|
||||
artwork = GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
|
||||
file = GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
playing = GObject.Property(type=bool, default=False)
|
||||
status = GObject.Property(type=str, default="Stopped")
|
||||
have_track = GObject.Property(type=bool, default=False)
|
||||
almost_done = GObject.Property(type=bool, default=False)
|
||||
playtime = GObject.Property(type=float)
|
||||
savedtime = GObject.Property(type=float)
|
||||
|
||||
bg_enabled = GObject.Property(type=bool, default=False)
|
||||
bg_volume = GObject.Property(type=float, default=0.5)
|
||||
pause_on_load = GObject.Property(type=bool, default=False)
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize the audio Player."""
|
||||
super().__init__()
|
||||
self._filter = filter.Filter()
|
||||
self._timeout = None
|
||||
|
||||
self._playbin = Gst.ElementFactory.make("playbin")
|
||||
self._playbin.set_property("audio-filter", self._filter)
|
||||
self._playbin.set_property("video-sink",
|
||||
Gst.ElementFactory.make("fakesink"))
|
||||
self._playbin.set_state(Gst.State.READY)
|
||||
|
||||
bus = self._playbin.get_bus()
|
||||
bus.add_signal_watch()
|
||||
bus.connect("message::async-done", self.__msg_async_done)
|
||||
bus.connect("message::eos", self.__msg_eos)
|
||||
bus.connect("message::state-changed", self.__msg_state_changed)
|
||||
bus.connect("message::stream-start", self.__msg_stream_start)
|
||||
bus.connect("message::tag", self.__msg_tags)
|
||||
|
||||
self.bind_property("volume", self._playbin, "volume")
|
||||
self.bind_property("bg-enabled", self._filter, "bg-enabled")
|
||||
self.bind_property("bg-volume", self._filter, "bg-volume")
|
||||
|
||||
self.connect("notify::file", self.__notify_file)
|
||||
|
||||
def __check_last_second(self) -> None:
|
||||
if self.duration - self.position <= 2 * (Gst.SECOND / Gst.USECOND):
|
||||
if not self.almost_done:
|
||||
self.emit("about-to-finish")
|
||||
|
||||
def __get_current_playtime(self) -> float:
|
||||
if not self._playbin.clock:
|
||||
return 0.0
|
||||
time = self._playbin.clock.get_time() - self._playbin.base_time
|
||||
return time / Gst.SECOND
|
||||
|
||||
def __msg_async_done(self, bus: Gst.Bus, message: Gst.Message) -> None:
|
||||
self.__update_position()
|
||||
|
||||
def __msg_eos(self, bus: Gst.Bus, message: Gst.Message) -> None:
|
||||
self.emit("eos")
|
||||
|
||||
def __msg_state_changed(self, bus: Gst.Bus, message: Gst.Message) -> None:
|
||||
if message.src == self._playbin:
|
||||
(old, new, pending) = message.parse_state_changed()
|
||||
match (self.status, new, pending):
|
||||
case ("Playing", Gst.State.PLAYING, _) | \
|
||||
("Paused", Gst.State.PAUSED, _) | \
|
||||
("Stopped", Gst.State.READY, _) | \
|
||||
("Stopped", Gst.State.NULL, _):
|
||||
pass
|
||||
case (_, Gst.State.PLAYING, Gst.State.VOID_PENDING):
|
||||
print("audio: state changed to 'playing'")
|
||||
self.status = "Playing"
|
||||
self.playing = True
|
||||
case (_, Gst.State.PAUSED, Gst.State.VOID_PENDING):
|
||||
print("audio: state changed to 'paused'")
|
||||
self.status = "Paused"
|
||||
self.playing = False
|
||||
case (_, Gst.State.READY, Gst.State.VOID_PENDING) | \
|
||||
(_, Gst.State.NULL, Gst.State.VOID_PENDING):
|
||||
print("audio: state changed to 'stopped'")
|
||||
self.status = "Stopped"
|
||||
self.playing = False
|
||||
|
||||
self.__update_timeout()
|
||||
|
||||
def __msg_stream_start(self, bus: Gst.Bus, message: Gst.Message) -> None:
|
||||
self.emit("file-loaded",
|
||||
path.from_uri(self._playbin.get_property("current-uri")))
|
||||
|
||||
def __msg_tags(self, bus: Gst.Bus, message: Gst.Message) -> None:
|
||||
taglist = message.parse_tag()
|
||||
for tag in ["artist", "album", "album-artist", "album-disc-number",
|
||||
"title", "track-number", "artwork"]:
|
||||
match tag:
|
||||
case "artwork":
|
||||
(res, sample) = taglist.get_sample("image")
|
||||
if res:
|
||||
buffer = sample.get_buffer()
|
||||
(res, map) = buffer.map(Gst.MapFlags.READ)
|
||||
if res:
|
||||
value = tmpdir.cover_jpg(map.data)
|
||||
buffer.unmap(map)
|
||||
case "track-number" | "album-disc-number":
|
||||
(res, value) = taglist.get_uint(tag)
|
||||
case _:
|
||||
(res, value) = taglist.get_string(tag)
|
||||
if res and self.get_property(tag) != value:
|
||||
self.set_property(tag, value)
|
||||
|
||||
def __notify_file(self, player: GObject.GObject, param) -> None:
|
||||
if self.file:
|
||||
uri = self.file.as_uri()
|
||||
print(f"audio: loading {uri}")
|
||||
self._playbin.set_property("uri", uri)
|
||||
|
||||
def __reset_properties(self, *, duration: float = 0.0,
|
||||
artwork: pathlib.Path | None = None) -> None:
|
||||
for tag in ["artist", "album-artist", "album", "title"]:
|
||||
self.set_property(tag, "")
|
||||
for tag in ["album-disc-number", "track-number",
|
||||
"position", "playtime", "savedtime"]:
|
||||
self.set_property(tag, 0)
|
||||
|
||||
self.almost_done = False
|
||||
self.pause_on_load = False
|
||||
self.artwork = artwork
|
||||
self.duration = duration
|
||||
|
||||
def __update_position(self) -> bool:
|
||||
(res, pos) = self._playbin.query_position(Gst.Format.TIME)
|
||||
self.position = pos / Gst.USECOND if res else 0
|
||||
self.playtime = self.__get_current_playtime() + self.savedtime
|
||||
self.__check_last_second()
|
||||
return GLib.SOURCE_CONTINUE
|
||||
|
||||
def __update_timeout(self) -> None:
|
||||
if self.playing and self._timeout is None:
|
||||
self._timeout = GLib.timeout_add(UPDATE_INTERVAL,
|
||||
self.__update_position)
|
||||
elif self.playing is False and self._timeout is not None:
|
||||
GLib.source_remove(self._timeout)
|
||||
self._timeout = None
|
||||
|
||||
def get_replaygain(self) -> tuple[bool, str | None]:
|
||||
"""Get the current ReplayGain mode."""
|
||||
mode = self._filter.rg_mode
|
||||
return (False, None) if mode == "disabled" else (True, mode)
|
||||
|
||||
def get_state(self) -> Gst.State:
|
||||
"""Get the current state of the Player."""
|
||||
return self._playbin.get_state(Gst.CLOCK_TIME_NONE).state
|
||||
|
||||
def pause(self, *args) -> None:
|
||||
"""Pause playback."""
|
||||
self.set_state_sync(Gst.State.PAUSED)
|
||||
|
||||
def play(self, *args) -> None:
|
||||
"""Start playback."""
|
||||
self.set_state_sync(Gst.State.PLAYING)
|
||||
|
||||
def play_pause(self, *args) -> None:
|
||||
"""Start or Pause playback."""
|
||||
state = Gst.State.PAUSED if self.playing else Gst.State.PLAYING
|
||||
self.set_state_sync(state)
|
||||
|
||||
def seek(self, newpos: float, *args) -> None:
|
||||
"""Seek to a different point in the stream."""
|
||||
self.savedtime += self.__get_current_playtime()
|
||||
self._playbin.seek_simple(Gst.Format.TIME, SEEK_FLAGS,
|
||||
newpos * Gst.USECOND)
|
||||
|
||||
def set_replaygain(self, enabled: bool, mode: str) -> None:
|
||||
"""Set the ReplayGain mode."""
|
||||
self._filter.rg_mode = mode if enabled else "disabled"
|
||||
|
||||
def set_state_sync(self, state: Gst.State) -> None:
|
||||
"""Set the state of the playbin, and wait for it to change."""
|
||||
if self._playbin.set_state(state) == Gst.StateChangeReturn.ASYNC:
|
||||
self.get_state()
|
||||
|
||||
def shutdown(self) -> None:
|
||||
"""Shut down the player."""
|
||||
self._playbin.set_state(Gst.State.NULL)
|
||||
|
||||
def stop(self, *args) -> None:
|
||||
"""Stop playback."""
|
||||
self.set_state_sync(Gst.State.READY)
|
||||
|
||||
@GObject.Signal
|
||||
def about_to_finish(self) -> None:
|
||||
"""Signal that playback is almost done."""
|
||||
print("audio: about to finish")
|
||||
self.almost_done = True
|
||||
|
||||
@GObject.Signal(arg_types=(GObject.TYPE_PYOBJECT,))
|
||||
def file_loaded(self, file: pathlib.Path) -> None:
|
||||
"""Signal that a new URI has started."""
|
||||
print("audio: file loaded")
|
||||
if self.pause_on_load:
|
||||
self._playbin.set_state(Gst.State.PAUSED)
|
||||
(res, dur) = self._playbin.query_duration(Gst.Format.TIME)
|
||||
cover = self.file.parent / "cover.jpg"
|
||||
self.__reset_properties(duration=(dur / Gst.USECOND if res else 0),
|
||||
artwork=(cover if cover.is_file() else None))
|
||||
self.have_track = True
|
||||
|
||||
@GObject.Signal
|
||||
def eos(self) -> None:
|
||||
"""Signal that the current track has ended."""
|
||||
print("audio: end of stream")
|
||||
self.set_state_sync(Gst.State.READY)
|
||||
self.__reset_properties()
|
||||
self.have_track = False
|
||||
self.file = None
|
|
@ -0,0 +1,45 @@
|
|||
# Copyright 2023 (c) Anna Schumaker.
|
||||
"""A custom Gst.Bin with our audio filter effects."""
|
||||
from gi.repository import GObject
|
||||
from gi.repository import Gst
|
||||
from . import replaygain
|
||||
|
||||
|
||||
class Filter(Gst.Bin):
|
||||
"""The audio filter element."""
|
||||
|
||||
bg_enabled = GObject.Property(type=bool, default=False)
|
||||
bg_volume = GObject.Property(type=float, default=0.5)
|
||||
rg_mode = GObject.Property(type=str, default="disabled")
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize the audio filter."""
|
||||
super().__init__()
|
||||
self._replaygain = replaygain.Filter()
|
||||
self._volume = Gst.ElementFactory.make("volume")
|
||||
|
||||
self.add(self._replaygain)
|
||||
self.add(self._volume)
|
||||
|
||||
rg_pad = self._replaygain.get_static_pad("src")
|
||||
rg_pad.link(self._volume.get_static_pad("sink"))
|
||||
|
||||
self.__add_ghost_pad("sink", self._replaygain)
|
||||
self.__add_ghost_pad("src", self._volume)
|
||||
|
||||
self.connect("notify", self.__notify)
|
||||
|
||||
def __add_ghost_pad(self, pad: str, elm: Gst.Element) -> None:
|
||||
self.add_pad(Gst.GhostPad.new(pad, elm.get_static_pad(pad)))
|
||||
|
||||
def __notify(self, filter: Gst.Bin, param: GObject.ParamSpec) -> None:
|
||||
match param.name:
|
||||
case "bg-enabled" | "bg-volume":
|
||||
vol = self.bg_volume if self.bg_enabled else 1.0
|
||||
if vol != self._volume.get_property("volume"):
|
||||
vs = f"{round(vol * 100)}%" if self.bg_enabled else "off"
|
||||
print(f"audio: setting background listening to {vs}")
|
||||
self._volume.set_property("volume", vol)
|
||||
case "rg-mode":
|
||||
if self.rg_mode != self._replaygain.mode:
|
||||
self._replaygain.mode = self.rg_mode
|
|
@ -0,0 +1,62 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""A custom Gst.Bin for selecting ReplayGain mode."""
|
||||
import collections
|
||||
from gi.repository import GObject
|
||||
from gi.repository import Gst
|
||||
|
||||
RequestPads = collections.namedtuple("RequestPads", ["src", "sink"])
|
||||
|
||||
|
||||
class Filter(Gst.Bin):
|
||||
"""The ReplayGain filter element."""
|
||||
|
||||
mode = GObject.Property(type=str, default="disabled")
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize the ReplayGain element."""
|
||||
super().__init__()
|
||||
self._src = Gst.ElementFactory.make("output-selector")
|
||||
self._sink = Gst.ElementFactory.make("input-selector")
|
||||
self._rgalbum = Gst.ElementFactory.make("rgvolume")
|
||||
self._rgtrack = Gst.ElementFactory.make("rgvolume")
|
||||
self._rglimit = Gst.ElementFactory.make("rglimiter")
|
||||
|
||||
for elm in [self._src, self._rgalbum, self._rgtrack,
|
||||
self._rglimit, self._sink]:
|
||||
self.add(elm)
|
||||
|
||||
self._disabled = self.__request_pads(self._rglimit)
|
||||
self._album_mode = self.__request_pads(self._rgalbum)
|
||||
self._track_mode = self.__request_pads(self._rgtrack)
|
||||
|
||||
self._rgalbum.set_property("pre-amp", 6.0)
|
||||
self._rgtrack.set_property("pre-amp", 6.0)
|
||||
self._rgtrack.set_property("album-mode", False)
|
||||
|
||||
self._src.set_property("pad-negotiation-mode", 2)
|
||||
self._src.set_property("active-pad", self._disabled.src)
|
||||
self._sink.set_property("active-pad", self._disabled.sink)
|
||||
|
||||
self.__add_ghost_pad("sink", self._src)
|
||||
self.__add_ghost_pad("src", self._sink)
|
||||
|
||||
self.connect("notify::mode", self.__notify_mode)
|
||||
|
||||
def __add_ghost_pad(self, pad: str, elm: Gst.Element) -> None:
|
||||
self.add_pad(Gst.GhostPad.new(pad, elm.get_static_pad(pad)))
|
||||
|
||||
def __request_pads(self, elm: Gst.Element) -> RequestPads:
|
||||
pads = RequestPads(src=self._src.request_pad_simple("src_%u"),
|
||||
sink=self._sink.request_pad_simple("sink_%u"))
|
||||
pads.src.link(elm.get_static_pad("sink"))
|
||||
elm.get_static_pad("src").link(pads.sink)
|
||||
return pads
|
||||
|
||||
def __notify_mode(self, filter: Gst.Bin, param) -> None:
|
||||
match self.mode:
|
||||
case "album": pads = self._album_mode
|
||||
case "track": pads = self._track_mode
|
||||
case _: pads = self._disabled
|
||||
print(f"audio: setting ReplayGain mode to '{self.mode}'")
|
||||
self._src.set_property("active-pad", pads.src)
|
||||
self._sink.set_property("active-pad", pads.sink)
|
|
@ -0,0 +1,168 @@
|
|||
# Copyright 2023 (c) Anna Schumaker
|
||||
"""Extract tags from an audio file."""
|
||||
import dataclasses
|
||||
import mutagen
|
||||
import pathlib
|
||||
import re
|
||||
|
||||
|
||||
@dataclasses.dataclass
|
||||
class _Artist:
|
||||
"""Class for holding Artist-related tags."""
|
||||
|
||||
name: str
|
||||
mbid: str
|
||||
|
||||
def __lt__(self, rhs) -> bool:
|
||||
lhs = (self.name is not None, self.name, self.mbid)
|
||||
return lhs < (rhs.name is not None, rhs.name, rhs.mbid)
|
||||
|
||||
|
||||
@dataclasses.dataclass
|
||||
class _Album:
|
||||
"""Class for holding Album-related tags."""
|
||||
|
||||
name: str
|
||||
mbid: str
|
||||
artist: str
|
||||
release: str
|
||||
cover: pathlib.Path
|
||||
artists: list[_Artist]
|
||||
|
||||
|
||||
@dataclasses.dataclass
|
||||
class _Medium:
|
||||
"""Class for holding Medium-related tags."""
|
||||
|
||||
number: int
|
||||
name: str
|
||||
type: str
|
||||
|
||||
|
||||
@dataclasses.dataclass
|
||||
class _Track:
|
||||
"""Class for holding Track-related tags."""
|
||||
|
||||
artist: str
|
||||
length: int
|
||||
mbid: int
|
||||
mtime: float
|
||||
number: int
|
||||
title: str
|
||||
|
||||
|
||||
class _Tags:
|
||||
"""Extract tags found in the Mutagen tag dictionary."""
|
||||
|
||||
def __init__(self, file: pathlib.Path, tags: dict,
|
||||
length: int = 0, mtime: float = 0.0):
|
||||
"""Initialize the Tagger."""
|
||||
self.file = file
|
||||
self.tags = tags
|
||||
|
||||
self.artists = sorted(self.list_artists())
|
||||
|
||||
self.album = _Album(tags.get("album", [""])[0],
|
||||
tags.get("musicbrainz_releasegroupid", [""])[0],
|
||||
self.get_album_artist(),
|
||||
self.get_release(),
|
||||
file.parent / "cover.jpg",
|
||||
sorted(self.list_album_artists()))
|
||||
|
||||
self.medium = _Medium(int(tags.get("discnumber", [1])[0]),
|
||||
tags.get("discsubtitle", [""])[0],
|
||||
tags.get("media", [""])[0])
|
||||
|
||||
self.track = _Track(tags.get("artist", [""])[0],
|
||||
length,
|
||||
tags.get("musicbrainz_releasetrackid", [""])[0],
|
||||
mtime,
|
||||
int(tags.get("tracknumber", [0])[0]),
|
||||
tags.get("title", [""])[0])
|
||||
|
||||
self.genres = sorted(self.list_genres())
|
||||
self.year = self.get_year()
|
||||
|
||||
def get_album_artist(self) -> str:
|
||||
"""Find the album artist of the file."""
|
||||
if (res := self.tags.get("albumartist")) is None:
|
||||
res = self.tags.get("artist", [""])
|
||||
return res[0]
|
||||
|
||||
def list_album_artists(self) -> list[_Artist]:
|
||||
"""Find the list of album artists for the track."""
|
||||
artists = self.tags.get("albumartist", [])
|
||||
mbids = self.tags.get("musicbrainz_albumartistid", len(artists) * [""])
|
||||
|
||||
if len(artists) != len(mbids):
|
||||
artists = [None] * len(mbids)
|
||||
|
||||
map = {a.mbid: a for a in self.artists}
|
||||
map.update({(a.name, a.mbid): a for a in self.artists})
|
||||
return [map.get(m, map.get((a, m))) for (a, m) in zip(artists, mbids)]
|
||||
|
||||
def list_artists(self) -> list[_Artist]:
|
||||
"""Find the list of artists for the track."""
|
||||
artists = self.tags.get("artists", [])
|
||||
mbids = self.tags.get("musicbrainz_artistid", len(artists) * [""])
|
||||
found = set()
|
||||
need = set()
|
||||
|
||||
if len(artists) == 0 and len(mbids) == 0:
|
||||
res = {(a, "") for a in self.tags.get("artist", [])}
|
||||
elif len(artists) == len(mbids):
|
||||
res = {(a, m) for (a, m) in zip(artists, mbids)}
|
||||
found.update({m for m in mbids if len(m)})
|
||||
else:
|
||||
res = {(None, mbid) for mbid in mbids}
|
||||
need.update({mbid for mbid in mbids if len(mbid)})
|
||||
|
||||
albumartists = self.tags.get("albumartist", [])
|
||||
mbids = self.tags.get("musicbrainz_albumartistid",
|
||||
len(albumartists) * [""])
|
||||
if len(albumartists) == len(mbids):
|
||||
res.update({(a, m) for (a, m) in zip(albumartists, mbids)})
|
||||
found.update({m for m in mbids if len(m)})
|
||||
else:
|
||||
res.update({(None, mbid) for mbid in mbids})
|
||||
need.update({mbid for mbid in mbids if len(mbid)})
|
||||
|
||||
res.difference_update({(None, mbid) for mbid in found & need})
|
||||
return [_Artist(a, m) for (a, m) in list(res)]
|
||||
|
||||
def list_genres(self) -> list[str]:
|
||||
"""Find the genres of the file."""
|
||||
res = []
|
||||
|
||||
for genre in self.tags.get("genre", []):
|
||||
res.extend([g.strip() for g in re.split("[,;/]", genre)])
|
||||
|
||||
for reltype in self.tags.get("releasetype", []):
|
||||
match reltype:
|
||||
case "album" | "compilation": continue
|
||||
case "ep": res.append("EP")
|
||||
case _: res.append(reltype.title())
|
||||
|
||||
return res
|
||||
|
||||
def get_release(self) -> str:
|
||||
"""Find the release date of the file."""
|
||||
if (res := self.tags.get("originaldate")) is None:
|
||||
if (res := self.tags.get("originalyear")) is None:
|
||||
if (res := self.tags.get("date")) is None:
|
||||
res = self.tags.get("year", [""])
|
||||
return res[0]
|
||||
|
||||
def get_year(self) -> int | None:
|
||||
"""Find the year in the release string."""
|
||||
if len(self.album.release):
|
||||
return int(re.match(r"\d+", self.album.release).group(0))
|
||||
|
||||
|
||||
def tag_file(file: pathlib.Path, mtime: float | None) -> _Tags | None:
|
||||
"""Tag the requested file."""
|
||||
if file.is_file():
|
||||
file_mtime = file.stat().st_mtime
|
||||
if mtime is None or file_mtime > mtime:
|
||||
if (tags := mutagen.File(file)) is not None:
|
||||
return _Tags(file, tags, tags.info.length, file_mtime)
|
|
@ -0,0 +1,152 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""Helper classes for Buttons."""
|
||||
from gi.repository import GObject
|
||||
from gi.repository import Gtk
|
||||
|
||||
|
||||
class Button(Gtk.Button):
|
||||
"""A Gtk.Button with extra properties and default large size."""
|
||||
|
||||
icon_name = GObject.Property(type=str)
|
||||
icon_opacity = GObject.Property(type=float, default=1.0,
|
||||
minimum=0.0, maximum=1.0)
|
||||
|
||||
def __init__(self, large_icon: bool = False, **kwargs):
|
||||
"""Initialize a Button."""
|
||||
super().__init__(focusable=False, **kwargs)
|
||||
icon_size = Gtk.IconSize.LARGE if large_icon else Gtk.IconSize.NORMAL
|
||||
self._image = Gtk.Image(icon_name=self.icon_name, icon_size=icon_size,
|
||||
opacity=self.icon_opacity)
|
||||
self.bind_property("icon-name", self._image, "icon-name")
|
||||
self.bind_property("icon-opacity", self._image, "opacity")
|
||||
self.set_child(self._image)
|
||||
|
||||
@GObject.Property(type=bool, default=False)
|
||||
def large_icon(self) -> bool:
|
||||
"""Get if this Button has a large icon."""
|
||||
return self._image.get_icon_size() == Gtk.IconSize.LARGE
|
||||
|
||||
@large_icon.setter
|
||||
def large_icon(self, newval: bool) -> None:
|
||||
size = Gtk.IconSize.LARGE if newval else Gtk.IconSize.NORMAL
|
||||
self._image.set_icon_size(size)
|
||||
|
||||
|
||||
class PopoverButton(Gtk.MenuButton):
|
||||
"""A MenuButton with a Gtk.Popover attached."""
|
||||
|
||||
popover_child = GObject.Property(type=Gtk.Widget)
|
||||
|
||||
def __init__(self, **kwargs):
|
||||
"""Initialize a popover.Button."""
|
||||
super().__init__(popover=Gtk.Popover(), **kwargs)
|
||||
self.bind_property("popover-child", self.get_popover(), "child")
|
||||
self.get_popover().set_child(self.popover_child)
|
||||
|
||||
def popdown(self):
|
||||
"""Close the popover."""
|
||||
self.get_popover().popdown()
|
||||
|
||||
|
||||
class SplitButton(Gtk.Box):
|
||||
"""A Button and secondary widget packed together."""
|
||||
|
||||
icon_name = GObject.Property(type=str)
|
||||
large_icon = GObject.Property(type=bool, default=False)
|
||||
|
||||
def __init__(self, secondary: Gtk.Button, **kwargs):
|
||||
"""Initialize a Split Button."""
|
||||
super().__init__(**kwargs)
|
||||
self._primary = Button(hexpand=True, icon_name=self.icon_name,
|
||||
large_icon=self.large_icon)
|
||||
self._separator = Gtk.Separator(orientation=Gtk.Orientation.VERTICAL,
|
||||
margin_top=12, margin_bottom=12)
|
||||
self._secondary = secondary
|
||||
|
||||
self.bind_property("icon-name", self._primary, "icon-name")
|
||||
self.bind_property("large-icon", self._primary, "large-icon")
|
||||
self._primary.connect("activate", self.__activate)
|
||||
self._primary.connect("clicked", self.__clicked)
|
||||
|
||||
self.append(self._primary)
|
||||
self.append(self._separator)
|
||||
self.append(secondary)
|
||||
|
||||
self.add_css_class("emmental-splitbutton")
|
||||
|
||||
def __activate(self, button: Button) -> None:
|
||||
self.emit("activate-primary")
|
||||
|
||||
def __clicked(self, button: Button) -> None:
|
||||
self.emit("clicked")
|
||||
|
||||
def activate(self, *args) -> None:
|
||||
"""Activate the primary button."""
|
||||
self._primary.activate()
|
||||
|
||||
@GObject.Property(type=Gtk.Button, flags=GObject.ParamFlags.READABLE)
|
||||
def secondary(self) -> Gtk.Button:
|
||||
"""Get the secondary button attached to the SplitButton."""
|
||||
return self._secondary
|
||||
|
||||
@GObject.Signal
|
||||
def activate_primary(self) -> None:
|
||||
"""Signal that the primary button has been activated."""
|
||||
|
||||
@GObject.Signal
|
||||
def clicked(self) -> None:
|
||||
"""Signal that the primary button has been clicked."""
|
||||
|
||||
|
||||
class ImageToggle(Button):
|
||||
"""Inspired by a ToggleButton, but changes image based on state."""
|
||||
|
||||
active_icon_name = GObject.Property(type=str)
|
||||
active_tooltip_text = GObject.Property(type=str)
|
||||
|
||||
inactive_icon_name = GObject.Property(type=str)
|
||||
inactive_tooltip_text = GObject.Property(type=str)
|
||||
|
||||
def __init__(self, active_icon_name: str, inactive_icon_name: str,
|
||||
active_tooltip_text: str | None = None,
|
||||
inactive_tooltip_text: str | None = None,
|
||||
*, active: bool = False, **kwargs) -> None:
|
||||
"""Initialize an ImageToggle button."""
|
||||
super().__init__(active_icon_name=active_icon_name,
|
||||
inactive_icon_name=inactive_icon_name,
|
||||
icon_name=inactive_icon_name,
|
||||
active_tooltip_text=active_tooltip_text,
|
||||
inactive_tooltip_text=inactive_tooltip_text,
|
||||
tooltip_text=inactive_tooltip_text,
|
||||
active=active, **kwargs)
|
||||
self.connect("notify", self.__notify)
|
||||
|
||||
def __notify(self, toggle: Button, param: GObject.ParamSpec) -> None:
|
||||
match (param.name, self.active):
|
||||
case ("active-tooltip-text", True) | \
|
||||
("inactive-tooltip-text", False):
|
||||
self.set_tooltip_text(self.get_property(param.name))
|
||||
|
||||
def do_clicked(self) -> None:
|
||||
"""Handle a click event."""
|
||||
self.active = not self.active
|
||||
|
||||
@GObject.Property(type=bool, default=False)
|
||||
def active(self) -> bool:
|
||||
"""Get the active state."""
|
||||
return self.icon_name == self.active_icon_name
|
||||
|
||||
@active.setter
|
||||
def active(self, newval: bool) -> None:
|
||||
if newval != self.active:
|
||||
if newval:
|
||||
self.icon_name = self.active_icon_name
|
||||
self.props.tooltip_text = self.active_tooltip_text
|
||||
else:
|
||||
self.icon_name = self.inactive_icon_name
|
||||
self.props.tooltip_text = self.inactive_tooltip_text
|
||||
self.emit("toggled")
|
||||
|
||||
@GObject.Signal
|
||||
def toggled(self) -> None:
|
||||
"""Active state has been toggled."""
|
|
@ -0,0 +1,114 @@
|
|||
# Copyright 2022 (c) Anna Schumaker
|
||||
"""Easily work with our underlying sqlite3 database."""
|
||||
import pathlib
|
||||
from gi.repository import GObject
|
||||
from typing import Generator
|
||||
from . import albums
|
||||
from . import artists
|
||||
from . import connection
|
||||
from . import decades
|
||||
from . import genres
|
||||
from . import libraries
|
||||
from . import playlist
|
||||
from . import media
|
||||
from . import playlists
|
||||
from . import settings
|
||||
from . import table
|
||||
from . import tracks
|
||||
from . import years
|
||||
|
||||
|
||||
SQL_V1_SCRIPT = pathlib.Path(__file__).parent / "emmental.sql"
|
||||
SQL_V2_SCRIPT = pathlib.Path(__file__).parent / "upgrade-v2.sql"
|
||||
SQL_V3_SCRIPT = pathlib.Path(__file__).parent / "upgrade-v3.sql"
|
||||
|
||||
|
||||
class Connection(connection.Connection):
|
||||
"""Connect to the database."""
|
||||
|
||||
active_playlist = GObject.Property(type=playlist.Playlist)
|
||||
loaded = GObject.Property(type=bool, default=False)
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize a sqlite connection."""
|
||||
super().__init__()
|
||||
self.__check_version()
|
||||
|
||||
self.settings = settings.Table(self)
|
||||
self.playlists = playlists.Table(self)
|
||||
self.artists = artists.Table(self)
|
||||
self.albums = albums.Table(self, queue=self.artists.queue)
|
||||
self.media = media.Table(self, queue=self.artists.queue)
|
||||
self.genres = genres.Table(self)
|
||||
self.decades = decades.Table(self)
|
||||
self.years = years.Table(self, queue=self.decades.queue)
|
||||
self.libraries = libraries.Table(self)
|
||||
|
||||
self.tracks = tracks.Table(self)
|
||||
|
||||
def __check_loaded(self) -> None:
|
||||
for tbl in list(self.playlist_tables()) + [self.tracks]:
|
||||
if tbl.loaded is False:
|
||||
return
|
||||
self.loaded = True
|
||||
|
||||
def __check_version(self) -> None:
|
||||
user_version = self("PRAGMA user_version").fetchone()["user_version"]
|
||||
match user_version:
|
||||
case 0:
|
||||
self.executescript(SQL_V1_SCRIPT)
|
||||
self.executescript(SQL_V2_SCRIPT)
|
||||
self.executescript(SQL_V3_SCRIPT)
|
||||
case 1:
|
||||
self.executescript(SQL_V2_SCRIPT)
|
||||
self.executescript(SQL_V3_SCRIPT)
|
||||
case 2:
|
||||
self.executescript(SQL_V3_SCRIPT)
|
||||
case 3: pass
|
||||
case _:
|
||||
raise Exception(f"Unsupported data version: {user_version}")
|
||||
|
||||
def close(self) -> None:
|
||||
"""Close the database connection."""
|
||||
self.settings.stop()
|
||||
for tbl in self.playlist_tables():
|
||||
tbl.stop()
|
||||
self.tracks.stop()
|
||||
|
||||
super().close()
|
||||
|
||||
def filter(self, glob: str) -> None:
|
||||
"""Filter the playlist tables."""
|
||||
for tbl in self.playlist_tables():
|
||||
tbl.filter(glob)
|
||||
|
||||
def load(self) -> None:
|
||||
"""Load the database tables."""
|
||||
self.settings.load()
|
||||
for tbl in self.playlist_tables():
|
||||
tbl.load()
|
||||
self.tracks.load()
|
||||
|
||||
def playlist_tables(self) -> Generator[playlist.Table, None, None]:
|
||||
"""Iterate over each playlist table."""
|
||||
for tbl in [self.playlists, self.artists, self.albums, self.media,
|
||||
self.genres, self.decades, self.years, self.libraries]:
|
||||
yield tbl
|
||||
|
||||
def set_active_playlist(self, plist: playlist.Playlist) -> None:
|
||||
"""Set the currently active playlist."""
|
||||
if self.active_playlist == plist:
|
||||
return
|
||||
if self.active_playlist is not None:
|
||||
self.active_playlist.active = False
|
||||
|
||||
self.active_playlist = plist
|
||||
|
||||
if plist is not None:
|
||||
plist.active = True
|
||||
|
||||
@GObject.Signal(arg_types=(table.Table,))
|
||||
def table_loaded(self, tbl: table.Table) -> None:
|
||||
"""Signal that a table has been loaded."""
|
||||
tbl.loaded = True
|
||||
self.__check_loaded()
|
|
@ -0,0 +1,157 @@
|
|||
# Copyright 2022 (c) Anna Schumaker
|
||||
"""A custom Gio.ListModel for working with albums."""
|
||||
import pathlib
|
||||
import sqlite3
|
||||
from gi.repository import GObject
|
||||
from .media import Medium
|
||||
from .. import format
|
||||
from . import playlist
|
||||
from . import tracks
|
||||
|
||||
|
||||
class Album(playlist.Playlist):
|
||||
"""Our custom Album with a ListModel representing mediums."""
|
||||
|
||||
albumid = GObject.Property(type=int)
|
||||
artist = GObject.Property(type=str)
|
||||
release = GObject.Property(type=str)
|
||||
mbid = GObject.Property(type=str)
|
||||
cover = GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
|
||||
def __init__(self, **kwargs):
|
||||
"""Initialize an Album object."""
|
||||
super().__init__(**kwargs)
|
||||
self.add_children(self.table.sql.media,
|
||||
self.table.get_mediumids(self))
|
||||
|
||||
def add_medium(self, medium: Medium) -> None:
|
||||
"""Add a Medium to this Album."""
|
||||
self.add_child(medium)
|
||||
|
||||
def get_artists(self) -> list[playlist.Playlist]:
|
||||
"""Get a list of artists for this album."""
|
||||
return self.table.get_artists(self)
|
||||
|
||||
def get_media(self) -> list[Medium]:
|
||||
"""Get a list of media for this album."""
|
||||
return self.table.get_media(self)
|
||||
|
||||
def has_medium(self, medium: Medium) -> bool:
|
||||
"""Check if a Medium is from this Album."""
|
||||
return self.has_child(medium)
|
||||
|
||||
def remove_medium(self, medium: Medium) -> None:
|
||||
"""Remove a Medium from this Album."""
|
||||
return self.remove_child(medium)
|
||||
|
||||
@property
|
||||
def primary_key(self) -> int:
|
||||
"""Get the Album primary key."""
|
||||
return self.albumid
|
||||
|
||||
@GObject.Property(type=playlist.Playlist)
|
||||
def parent(self) -> playlist.Playlist | None:
|
||||
"""Get the parent playlist of this Album."""
|
||||
artists = self.get_artists()
|
||||
return artists[0] if len(artists) else None
|
||||
|
||||
|
||||
class Table(playlist.Table):
|
||||
"""Our Album Table."""
|
||||
|
||||
def __init__(self, sql: GObject.TYPE_PYOBJECT, **kwargs):
|
||||
"""Initialize the Album Table."""
|
||||
super().__init__(sql=sql, autodelete=True,
|
||||
system_tracks=False, **kwargs)
|
||||
|
||||
def do_add_track(self, album: Album, track: tracks.Track) -> bool:
|
||||
"""Verify adding a Track to the Album playlist."""
|
||||
return track.get_medium().get_album() == album
|
||||
|
||||
def do_construct(self, **kwargs) -> Album:
|
||||
"""Construct a new album."""
|
||||
return Album(**kwargs)
|
||||
|
||||
def do_get_sort_key(self, album: Album) -> tuple[tuple, bool,
|
||||
str, tuple, str]:
|
||||
"""Get a sort key for the requested Artist."""
|
||||
return (format.sort_key(album.name),
|
||||
len(album.mbid) == 0, album.mbid.casefold(),
|
||||
format.sort_key(album.artist),
|
||||
album.release)
|
||||
|
||||
def do_remove_track(self, album: Album, track: tracks.Track) -> bool:
|
||||
"""Verify removing a Track from the Album playlist."""
|
||||
return True
|
||||
|
||||
def do_sql_delete(self, album: Album) -> sqlite3.Cursor:
|
||||
"""Delete an album."""
|
||||
for artist in album.get_artists():
|
||||
artist.remove_album(album)
|
||||
for medium in album.get_media():
|
||||
medium.delete()
|
||||
return self.sql("DELETE FROM albums WHERE albumid=?", album.albumid)
|
||||
|
||||
def do_sql_glob(self, glob: str) -> sqlite3.Cursor:
|
||||
"""Search for albums matching the search text."""
|
||||
return self.sql("""SELECT albumid FROM album_artist_view
|
||||
WHERE CASEFOLD(album) GLOB :glob
|
||||
OR CASEFOLD(medium) GLOB :glob""", glob=glob)
|
||||
|
||||
def do_sql_insert(self, name: str, artist: str,
|
||||
release: str, *, mbid: str = "",
|
||||
cover: pathlib.Path = None) -> sqlite3.Cursor | None:
|
||||
"""Create a new album."""
|
||||
if cur := self.sql("""INSERT INTO albums
|
||||
(name, artist, release, mbid, cover)
|
||||
VALUES (?, ?, ?, ?, ?)""",
|
||||
name, artist, release, mbid, cover):
|
||||
return self.sql("SELECT * FROM albums_view WHERE albumid=?",
|
||||
cur.lastrowid)
|
||||
|
||||
def do_sql_select_all(self) -> sqlite3.Cursor:
|
||||
"""Load albums from the database."""
|
||||
return self.sql("SELECT * FROM albums_view")
|
||||
|
||||
def do_sql_select_one(self, name: str = None,
|
||||
artist: str = None, release: str = None,
|
||||
*, mbid: str = "") -> sqlite3.Cursor:
|
||||
"""Look up an albums by name, mbid, artist, and release."""
|
||||
where = ["mbid=?"]
|
||||
args = [mbid.lower()]
|
||||
|
||||
if None not in (name, artist, release):
|
||||
where.extend(["CASEFOLD(name)=?",
|
||||
"CASEFOLD(artist)=?", "release=?"])
|
||||
args.extend([name.casefold(), artist.casefold(), release])
|
||||
|
||||
return self.sql(f"""SELECT albumid FROM albums
|
||||
WHERE {" AND ".join(where)}""", *args)
|
||||
|
||||
def do_sql_select_trackids(self, album: Album) -> sqlite3.Cursor:
|
||||
"""Load an Album's Tracks from the database."""
|
||||
return self.sql("""SELECT trackid FROM album_tracks_view
|
||||
WHERE albumid=?""", album.albumid)
|
||||
|
||||
def do_sql_update(self, album: Album, column: str, newval) -> bool:
|
||||
"""Rename an album."""
|
||||
return self.sql(f"UPDATE albums SET {column}=? WHERE albumid=?",
|
||||
newval, album.albumid)
|
||||
|
||||
def get_artists(self, album: Album) -> list[playlist.Playlist]:
|
||||
"""Get the list of artists for this album."""
|
||||
rows = self.sql("""SELECT artistid FROM album_artist_link
|
||||
WHERE albumid=?""", album.albumid).fetchall()
|
||||
artists = [self.sql.artists.rows.get(row["artistid"]) for row in rows]
|
||||
return list(filter(None, artists))
|
||||
|
||||
def get_media(self, album: Album) -> list[Medium]:
|
||||
"""Get the list of media for this album."""
|
||||
return [self.sql.media.rows.get(id)
|
||||
for id in self.get_mediumids(album)]
|
||||
|
||||
def get_mediumids(self, album: Album) -> set[int]:
|
||||
"""Get the set of mediumids for this album."""
|
||||
rows = self.sql("SELECT mediumid FROM media WHERE albumid=?",
|
||||
album.albumid)
|
||||
return {row["mediumid"] for row in rows.fetchall()}
|
|
@ -0,0 +1,147 @@
|
|||
# Copyright 2022 (c) Anna Schumaker
|
||||
"""A custom Gio.ListModel for working with artists."""
|
||||
import sqlite3
|
||||
from gi.repository import GObject
|
||||
from gi.repository import Gtk
|
||||
from .albums import Album
|
||||
from .. import format
|
||||
from . import playlist
|
||||
from . import table
|
||||
|
||||
|
||||
class Artist(playlist.Playlist):
|
||||
"""Our custom Artist object."""
|
||||
|
||||
artistid = GObject.Property(type=int)
|
||||
mbid = GObject.Property(type=str)
|
||||
|
||||
def __init__(self, **kwargs):
|
||||
"""Initialize an Artist object."""
|
||||
super().__init__(**kwargs)
|
||||
self.add_children(self.table.sql.albums,
|
||||
self.table.get_albumids(self))
|
||||
|
||||
def add_album(self, album: Album) -> None:
|
||||
"""Add an Album to this Artist."""
|
||||
if self.table.add_album(self, album):
|
||||
self.add_child(album)
|
||||
|
||||
def has_album(self, album: Album) -> bool:
|
||||
"""Check if the Artist has this Album."""
|
||||
return self.has_child(album)
|
||||
|
||||
def remove_album(self, album: Album) -> None:
|
||||
"""Remove an album from this Artist."""
|
||||
self.table.remove_album(self, album)
|
||||
self.remove_child(album)
|
||||
|
||||
@property
|
||||
def primary_key(self) -> int:
|
||||
"""Get the Artist primary key."""
|
||||
return self.artistid
|
||||
|
||||
|
||||
class Filter(table.KeySet):
|
||||
"""Custom filter to hide artists without albums."""
|
||||
|
||||
show_all = GObject.Property(type=bool, default=False)
|
||||
|
||||
def __init__(self, show_all: bool = False):
|
||||
"""Initialize the Artist filter."""
|
||||
super().__init__(show_all=show_all)
|
||||
self.connect("notify::show-all", self.__notify_show_all)
|
||||
|
||||
def __notify_show_all(self, filter: table.KeySet, param) -> None:
|
||||
self.changed(Gtk.FilterChange.LESS_STRICT if self.show_all else
|
||||
Gtk.FilterChange.MORE_STRICT)
|
||||
|
||||
def do_get_strictness(self) -> Gtk.FilterMatch:
|
||||
"""Get the strictness of the filter."""
|
||||
res = super().do_get_strictness()
|
||||
if not self.show_all and res == Gtk.FilterMatch.ALL:
|
||||
return Gtk.FilterMatch.SOME
|
||||
return res
|
||||
|
||||
def do_match(self, artist: Artist) -> bool:
|
||||
"""Check if the artist matches the filter."""
|
||||
res = super().do_match(artist)
|
||||
if not self.show_all and res:
|
||||
return artist.child_set.keyset.n_keys > 0
|
||||
return res
|
||||
|
||||
|
||||
class Table(playlist.Table):
|
||||
"""Our Artist Table."""
|
||||
|
||||
show_all = GObject.Property(type=bool, default=False)
|
||||
|
||||
def __init__(self, sql: GObject.TYPE_PYOBJECT,
|
||||
show_all: bool = False, **kwargs):
|
||||
"""Initialize an Artist model."""
|
||||
super().__init__(sql=sql, show_all=show_all, autodelete=True,
|
||||
filter=Filter(show_all=show_all), **kwargs)
|
||||
self.bind_property("show-all", self.get_filter(), "show-all")
|
||||
|
||||
def do_construct(self, **kwargs) -> Artist:
|
||||
"""Construct a new artist."""
|
||||
return Artist(**kwargs)
|
||||
|
||||
def do_get_sort_key(self, artist: Artist) -> tuple[tuple, bool, str]:
|
||||
"""Get a sort key for the requested Playlist."""
|
||||
return (format.sort_key(artist.name),
|
||||
len(artist.mbid) == 0,
|
||||
artist.mbid.casefold())
|
||||
|
||||
def do_sql_delete(self, artist: Artist) -> bool:
|
||||
"""Delete an artist."""
|
||||
return self.sql("DELETE FROM artists WHERE artistid=?",
|
||||
artist.artistid)
|
||||
|
||||
def do_sql_glob(self, glob: str) -> sqlite3.Cursor:
|
||||
"""Search for artists matching the search text."""
|
||||
return self.sql("""SELECT artistid FROM album_artist_view
|
||||
WHERE CASEFOLD(artist) GLOB :glob
|
||||
OR CASEFOLD(album) GLOB :glob
|
||||
OR CASEFOLD(medium) GLOB :glob""", glob=glob)
|
||||
|
||||
def do_sql_insert(self, name: str,
|
||||
mbid: str = "") -> sqlite3.Cursor | None:
|
||||
"""Create a new artist."""
|
||||
if cur := self.sql("INSERT INTO artists (name, mbid) VALUES (?, ?)",
|
||||
name, mbid):
|
||||
return self.sql("SELECT * FROM artists_view WHERE artistid=?",
|
||||
cur.lastrowid)
|
||||
|
||||
def do_sql_select_all(self) -> sqlite3.Cursor:
|
||||
"""Load artists from the database."""
|
||||
return self.sql("SELECT * FROM artists_view")
|
||||
|
||||
def do_sql_select_one(self, name: str | None = None,
|
||||
*, mbid: str = "") -> sqlite3.Cursor:
|
||||
"""Look up an artist by name and mbid."""
|
||||
where = "mbid=? AND CASEFOLD(name)=?" if name else "mbid=?"
|
||||
args = [mbid.lower(), name.casefold()] if name else [mbid.lower()]
|
||||
return self.sql(f"SELECT artistid FROM artists WHERE {where}", *args)
|
||||
|
||||
def do_sql_update(self, artist: Artist,
|
||||
column: str, newval) -> sqlite3.Cursor:
|
||||
"""Update an artist."""
|
||||
return self.sql(f"UPDATE artists SET {column}=? WHERE artistid=?",
|
||||
newval, artist.artistid)
|
||||
|
||||
def add_album(self, artist: Artist, album: Album) -> bool:
|
||||
"""Add an album to this artist."""
|
||||
return self.sql("INSERT INTO album_artist_link VALUES (?, ?)",
|
||||
artist.artistid, album.albumid) is not None
|
||||
|
||||
def get_albumids(self, artist: Artist) -> set[int]:
|
||||
"""Get an Artist's associated albumids from the database."""
|
||||
cur = self.sql("""SELECT albumid FROM album_artist_link
|
||||
WHERE artistid=?""", artist.artistid)
|
||||
return {row["albumid"] for row in cur.fetchall()}
|
||||
|
||||
def remove_album(self, artist: Artist, album: Album) -> bool:
|
||||
"""Remove an album from this artist."""
|
||||
return self.sql("""DELETE FROM album_artist_link
|
||||
WHERE artistid=? AND albumid=?""",
|
||||
artist.artistid, album.albumid).rowcount == 1
|
|
@ -0,0 +1,95 @@
|
|||
# Copyright 2022 (c) Anna Schumaker
|
||||
"""Easily work with our underlying sqlite3 database."""
|
||||
import pathlib
|
||||
import sqlite3
|
||||
import sys
|
||||
from gi.repository import GObject
|
||||
from .. import gsetup
|
||||
|
||||
|
||||
DATA_FILE = gsetup.DATA_DIR / f"emmental{gsetup.DEBUG_STR}.sqlite3"
|
||||
DATABASE = ":memory:" if "unittest" in sys.modules else DATA_FILE
|
||||
|
||||
|
||||
def adapt_path(path: pathlib.Path) -> str:
|
||||
"""Adapt a pathlib.Path into a sqlite3 string."""
|
||||
return str(path)
|
||||
|
||||
|
||||
def convert_path(path: bytes) -> pathlib.Path:
|
||||
"""Convert a path string into a pathlib.Path object."""
|
||||
return pathlib.Path(path.decode())
|
||||
|
||||
|
||||
sqlite3.register_adapter(pathlib.PosixPath, adapt_path)
|
||||
sqlite3.register_converter("path", convert_path)
|
||||
|
||||
|
||||
class Connection(GObject.GObject):
|
||||
"""Connect to the database."""
|
||||
|
||||
connected = GObject.Property(type=bool, default=True)
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize a sqlite connection."""
|
||||
super().__init__()
|
||||
self._sql = sqlite3.connect(DATABASE,
|
||||
detect_types=sqlite3.PARSE_DECLTYPES)
|
||||
self._sql.create_function("CASEFOLD", 1,
|
||||
lambda s: s.casefold() if s else None,
|
||||
deterministic=True)
|
||||
self._sql.row_factory = sqlite3.Row
|
||||
self._sql("PRAGMA foreign_keys = ON")
|
||||
|
||||
def __call__(self, statement: str,
|
||||
*args, **kwargs) -> sqlite3.Cursor | None:
|
||||
"""Execute a SQL statement."""
|
||||
try:
|
||||
return self._sql.execute(statement, args if len(args) else kwargs)
|
||||
except sqlite3.IntegrityError:
|
||||
return None
|
||||
|
||||
def __del__(self) -> None:
|
||||
"""Clean up before exiting."""
|
||||
self.close()
|
||||
|
||||
def __enter__(self) -> None:
|
||||
"""Begin a transaction."""
|
||||
if not self._sql.in_transaction:
|
||||
self._sql.commit()
|
||||
self._sql.execute("BEGIN")
|
||||
|
||||
def __exit__(self, exp_type, exp_value, traceback) -> bool:
|
||||
"""Either commit or rollback an active transaction."""
|
||||
if exp_type is None:
|
||||
self._sql.commit()
|
||||
else:
|
||||
self._sql.rollback()
|
||||
return exp_type is None
|
||||
|
||||
def close(self) -> None:
|
||||
"""Close the database connection."""
|
||||
if self.connected:
|
||||
self._sql.commit()
|
||||
self._sql.execute("PRAGMA optimize")
|
||||
self._sql.close()
|
||||
self.connected = False
|
||||
|
||||
def commit(self) -> None:
|
||||
"""Commit pending changes."""
|
||||
self._sql.commit()
|
||||
|
||||
def executemany(self, statement: str, *args) -> sqlite3.Cursor | None:
|
||||
"""Execute several similar SQL statements at once."""
|
||||
try:
|
||||
return self._sql.executemany(statement, args)
|
||||
except sqlite3.InternalError:
|
||||
return None
|
||||
|
||||
def executescript(self, script: pathlib.Path) -> sqlite3.Cursor | None:
|
||||
"""Execute a SQL script."""
|
||||
if script.is_file():
|
||||
with open(script) as f:
|
||||
cur = self._sql.executescript(f.read())
|
||||
self.commit()
|
||||
return cur
|
|
@ -0,0 +1,109 @@
|
|||
# Copyright 2022 (c) Anna Schumaker
|
||||
"""A custom Gio.ListModel for working with decades."""
|
||||
import sqlite3
|
||||
from gi.repository import GObject
|
||||
from .years import Year
|
||||
from . import playlist
|
||||
from . import tracks
|
||||
|
||||
|
||||
class Decade(playlist.Playlist):
|
||||
"""Our custom Decade object."""
|
||||
|
||||
decade = GObject.Property(type=int)
|
||||
|
||||
def __init__(self, **kwargs):
|
||||
"""Initialize a Decade object."""
|
||||
super().__init__(**kwargs)
|
||||
self.add_children(self.table.sql.years,
|
||||
self.table.get_yearids(self))
|
||||
|
||||
def add_year(self, year: Year) -> None:
|
||||
"""Add a year to this decade."""
|
||||
self.add_child(year)
|
||||
|
||||
def get_years(self) -> list[Year]:
|
||||
"""Get a list of years for this decade."""
|
||||
return self.table.get_years(self)
|
||||
|
||||
def has_year(self, year: Year) -> bool:
|
||||
"""Check if the year is in this decade."""
|
||||
return self.has_child(year)
|
||||
|
||||
def remove_year(self, year: Year) -> None:
|
||||
"""Remove a year from this decade."""
|
||||
self.remove_child(year)
|
||||
|
||||
@property
|
||||
def primary_key(self) -> int:
|
||||
"""Get the primary key of this Decade."""
|
||||
return self.decade
|
||||
|
||||
|
||||
class Table(playlist.Table):
|
||||
"""Our Decade Table."""
|
||||
|
||||
def __init__(self, sql: GObject.TYPE_PYOBJECT, **kwargs):
|
||||
"""Initialize the Decade table."""
|
||||
super().__init__(sql=sql, autodelete=True,
|
||||
system_tracks=False, **kwargs)
|
||||
|
||||
def do_add_track(self, decade: Decade, track: tracks.Track) -> bool:
|
||||
"""Verify adding a Track to the Decade playlist."""
|
||||
return (track.year // 10 * 10) == decade.decade
|
||||
|
||||
def do_construct(self, **kwargs) -> Decade:
|
||||
"""Construct a new Decade playlist."""
|
||||
return Decade(**kwargs)
|
||||
|
||||
def do_get_sort_key(self, decade: Decade) -> int:
|
||||
"""Get the sort key for the requested decade."""
|
||||
return decade.decade
|
||||
|
||||
def do_remove_track(self, decade: Decade, track: tracks.Track) -> bool:
|
||||
"""Verify removing a Track from the Decade playlist."""
|
||||
return True
|
||||
|
||||
def do_sql_delete(self, decade: Decade) -> sqlite3.Cursor:
|
||||
"""Delete a decade."""
|
||||
for year in decade.get_years():
|
||||
year.delete()
|
||||
return self.sql("DELETE FROM decades WHERE decade=?", decade.decade)
|
||||
|
||||
def do_sql_glob(self, glob: str) -> sqlite3.Cursor:
|
||||
"""Search for decades matching the search text."""
|
||||
return self.sql("""SELECT decade FROM decades_view
|
||||
WHERE CASEFOLD(name) GLOB :glob
|
||||
UNION SELECT (year / 10 * 10) AS decade
|
||||
FROM years WHERE year GLOB :glob""", glob=glob)
|
||||
|
||||
def do_sql_insert(self, year: int) -> sqlite3.Cursor | None:
|
||||
"""Create a new Decade playlist."""
|
||||
decade = year // 10 * 10
|
||||
if self.sql("INSERT INTO decades (decade) VALUES (?)", decade):
|
||||
return self.sql("SELECT * FROM decades_view WHERE decade=?",
|
||||
decade)
|
||||
|
||||
def do_sql_select_all(self) -> sqlite3.Cursor:
|
||||
"""Load Decades from the database."""
|
||||
return self.sql("SELECT * FROM decades_view")
|
||||
|
||||
def do_sql_select_one(self, year: int) -> sqlite3.Cursor:
|
||||
"""Look up an decade by year."""
|
||||
return self.sql("SELECT decade FROM decades WHERE decade=?",
|
||||
year // 10 * 10)
|
||||
|
||||
def do_sql_select_trackids(self, decade: Decade) -> sqlite3.Cursor:
|
||||
"""Load a Decade's Tracks from the database."""
|
||||
return self.sql("""SELECT trackid FROM decade_tracks_view
|
||||
WHERE decade=?""", decade.decade)
|
||||
|
||||
def get_yearids(self, decade: Decade) -> set[int]:
|
||||
"""Get the set of years for this decade."""
|
||||
rows = self.sql("SELECT year FROM years WHERE (year / 10 * 10)=?",
|
||||
decade.decade)
|
||||
return {row["year"] for row in rows}
|
||||
|
||||
def get_years(self, decade: Decade) -> list[Year]:
|
||||
"""Get the list of years for this decade."""
|
||||
return [self.sql.years.rows.get(yr) for yr in self.get_yearids(decade)]
|
|
@ -0,0 +1,633 @@
|
|||
/* Copyright 2022 (c) Anna Schumaker */
|
||||
|
||||
PRAGMA user_version = 1;
|
||||
|
||||
|
||||
/**************************************
|
||||
* *
|
||||
* Application Settings *
|
||||
* *
|
||||
**************************************/
|
||||
|
||||
CREATE TABLE settings (
|
||||
key TEXT PRIMARY KEY,
|
||||
type TEXT NOT NULL,
|
||||
value TEXT NOT NULL,
|
||||
CHECK (type IN ("gint", "gdouble", "gboolean", "gchararray"))
|
||||
);
|
||||
|
||||
|
||||
/*************************************
|
||||
* *
|
||||
* Playlist Properties *
|
||||
* *
|
||||
*************************************/
|
||||
|
||||
CREATE TABLE playlist_properties (
|
||||
propertyid INTEGER PRIMARY KEY,
|
||||
active BOOLEAN NOT NULL DEFAULT FALSE,
|
||||
loop STRING NOT NULL DEFAULT "None",
|
||||
shuffle BOOLEAN NOT NULL DEFAULT FALSE,
|
||||
sort_order STRING NOT NULL DEFAULT "",
|
||||
current_trackid INTEGER DEFAULT NULL REFERENCES tracks (trackid)
|
||||
ON DELETE SET NULL
|
||||
ON UPDATE CASCADE,
|
||||
CHECK (loop IN ("None", "Track", "Playlist"))
|
||||
);
|
||||
|
||||
CREATE TRIGGER playlists_active_trigger
|
||||
AFTER UPDATE OF active ON playlist_properties
|
||||
FOR EACH ROW BEGIN
|
||||
UPDATE playlist_properties
|
||||
SET active = FALSE
|
||||
WHERE propertyid != NEW.propertyid AND active == TRUE;
|
||||
END;
|
||||
|
||||
|
||||
/*******************************************
|
||||
* *
|
||||
* User and System Playlists *
|
||||
* *
|
||||
*******************************************/
|
||||
|
||||
CREATE TABLE playlists (
|
||||
playlistid INTEGER PRIMARY KEY,
|
||||
propertyid INTEGER REFERENCES playlist_properties(propertyid)
|
||||
ON DELETE CASCADE
|
||||
ON UPDATE CASCADE,
|
||||
name TEXT NOT NULL UNIQUE COLLATE NOCASE,
|
||||
image PATH
|
||||
);
|
||||
|
||||
CREATE VIEW playlists_view AS
|
||||
SELECT playlistid, propertyid, name, image,
|
||||
active, loop, shuffle, sort_order, current_trackid
|
||||
FROM playlists
|
||||
JOIN playlist_properties USING (propertyid);
|
||||
|
||||
CREATE TRIGGER playlists_insert_trigger AFTER INSERT ON playlists
|
||||
BEGIN
|
||||
INSERT INTO playlist_properties (active, loop, sort_order)
|
||||
VALUES (NEW.name == "Collection",
|
||||
IIF(NEW.name == "Collection", "Playlist", "None"),
|
||||
CASE
|
||||
WHEN NEW.name == "Most Played Tracks"
|
||||
THEN "playcount DESC, albumartist, album, mediumno, number"
|
||||
WHEN NEW.name == "Previous Tracks"
|
||||
THEN "laststarted DESC"
|
||||
ELSE "albumartist, album, mediumno, number"
|
||||
END);
|
||||
UPDATE playlists SET propertyid = last_insert_rowid()
|
||||
WHERE playlistid = NEW.playlistid;
|
||||
END;
|
||||
|
||||
CREATE TRIGGER playlists_delete_trigger AFTER DELETE ON playlists
|
||||
BEGIN
|
||||
DELETE FROM playlist_properties WHERE propertyid = OLD.propertyid;
|
||||
END;
|
||||
|
||||
CREATE TRIGGER collection_loop_trigger
|
||||
BEFORE UPDATE OF loop ON playlist_properties
|
||||
WHEN NEW.loop == "None" AND NEW.propertyid == (SELECT propertyid
|
||||
FROM playlists
|
||||
WHERE name='Collection')
|
||||
BEGIN
|
||||
SELECT RAISE(ABORT, "Collection playlist cannot disable loop");
|
||||
END;
|
||||
|
||||
CREATE TRIGGER previous_loop_trigger
|
||||
BEFORE UPDATE OF loop ON playlist_properties
|
||||
WHEN NEW.loop != "None" AND NEW.propertyid == (SELECT propertyid
|
||||
FROM playlists
|
||||
WHERE name='Previous Tracks')
|
||||
BEGIN
|
||||
SELECT RAISE(ABORT, "Previous Tracks cannot be looped");
|
||||
END;
|
||||
|
||||
CREATE TRIGGER previous_shuffle_trigger
|
||||
BEFORE UPDATE OF shuffle ON playlist_properties
|
||||
WHEN NEW.shuffle = TRUE AND NEW.propertyid == (SELECT propertyid
|
||||
FROM playlists
|
||||
WHERE name='Previous Tracks')
|
||||
BEGIN
|
||||
SELECT RAISE(ABORT, "Previous Tracks cannot be shuffled");
|
||||
END;
|
||||
|
||||
CREATE TRIGGER previous_sort_order_trigger
|
||||
BEFORE UPDATE OF sort_order ON playlist_properties
|
||||
WHEN NEW.sort_order != "laststarted DESC" AND NEW.propertyid == (SELECT propertyid
|
||||
FROM playlists
|
||||
WHERE name='Previous Tracks')
|
||||
BEGIN
|
||||
SELECT RAISE(ABORT, "Previous Tracks cannot be sorted");
|
||||
END;
|
||||
|
||||
|
||||
/*************************
|
||||
* *
|
||||
* Artists *
|
||||
* *
|
||||
*************************/
|
||||
|
||||
CREATE TABLE artists (
|
||||
artistid INTEGER PRIMARY KEY,
|
||||
propertyid INTEGER REFERENCES playlist_properties (propertyid)
|
||||
ON DELETE CASCADE
|
||||
ON UPDATE CASCADE,
|
||||
name TEXT NOT NULL COLLATE NOCASE,
|
||||
mbid TEXT NOT NULL DEFAULT "" COLLATE NOCASE,
|
||||
UNIQUE (name, mbid)
|
||||
);
|
||||
|
||||
CREATE VIEW artists_view AS
|
||||
SELECT artistid, propertyid, name, mbid,
|
||||
active, loop, shuffle, sort_order, current_trackid
|
||||
FROM artists
|
||||
JOIN playlist_properties USING (propertyid);
|
||||
|
||||
|
||||
CREATE TRIGGER artists_insert_trigger AFTER INSERT ON artists
|
||||
BEGIN
|
||||
INSERT INTO playlist_properties (active, sort_order)
|
||||
VALUES (False, "release, album, mediumno, number");
|
||||
UPDATE artists SET propertyid = last_insert_rowid(),
|
||||
mbid = LOWER(NEW.mbid)
|
||||
WHERE artistid = NEW.artistid;
|
||||
END;
|
||||
|
||||
CREATE TRIGGER artists_delete_trigger AFTER DELETE ON artists
|
||||
BEGIN
|
||||
DELETE FROM playlist_properties WHERE propertyid = OLD.propertyid;
|
||||
END;
|
||||
|
||||
|
||||
/************************
|
||||
* *
|
||||
* Albums *
|
||||
* *
|
||||
************************/
|
||||
|
||||
CREATE TABLE albums (
|
||||
albumid INTEGER PRIMARY KEY,
|
||||
propertyid INTEGER REFERENCES playlist_properties (propertyid)
|
||||
ON DELETE CASCADE
|
||||
ON UPDATE CASCADE,
|
||||
name TEXT NOT NULL COLLATE NOCASE,
|
||||
artist TEXT NOT NULL COLLATE NOCASE,
|
||||
release TEXT NOT NULL,
|
||||
mbid TEXT NOT NULL DEFAULT "" COLLATE NOCASE,
|
||||
cover PATH,
|
||||
UNIQUE (name, mbid, artist, release)
|
||||
);
|
||||
|
||||
CREATE VIEW albums_view AS
|
||||
SELECT albumid, propertyid, name, mbid, artist, release, cover,
|
||||
active, loop, shuffle, sort_order, current_trackid
|
||||
FROM albums
|
||||
JOIN playlist_properties USING (propertyid);
|
||||
|
||||
|
||||
CREATE TRIGGER albums_insert_trigger AFTER INSERT ON albums
|
||||
BEGIN
|
||||
INSERT INTO playlist_properties (active, sort_order)
|
||||
VALUES (False, "mediumno, number");
|
||||
UPDATE albums SET propertyid = last_insert_rowid(),
|
||||
mbid = LOWER(NEW.mbid)
|
||||
WHERE albumid = NEW.albumid;
|
||||
END;
|
||||
|
||||
CREATE TRIGGER albums_delete_trigger AFTER DELETE ON albums
|
||||
BEGIN
|
||||
DELETE FROM playlist_properties WHERE propertyid = OLD.propertyid;
|
||||
END;
|
||||
|
||||
|
||||
/*************************
|
||||
* *
|
||||
* Mediums *
|
||||
* *
|
||||
*************************/
|
||||
|
||||
CREATE TABLE media (
|
||||
mediumid INTEGER PRIMARY KEY,
|
||||
propertyid INTEGER REFERENCES playlist_properties (propertyid)
|
||||
ON DELETE CASCADE
|
||||
ON UPDATE CASCADE,
|
||||
albumid INTEGER NOT NULL REFERENCES albums (albumid)
|
||||
ON DELETE CASCADE
|
||||
ON UPDATE CASCADE,
|
||||
number INTEGER NOT NULL,
|
||||
name TEXT NOT NULL DEFAULT "" COLLATE NOCASE,
|
||||
type TEXT NOT NULL DEFAULT "" COLLATE NOCASE,
|
||||
UNIQUE (albumid, number, type)
|
||||
);
|
||||
|
||||
CREATE VIEW media_view AS
|
||||
SELECT mediumid, propertyid, albumid, number, name, type,
|
||||
active, loop, shuffle, sort_order, current_trackid
|
||||
FROM media
|
||||
JOIN playlist_properties USING (propertyid);
|
||||
|
||||
CREATE TRIGGER media_insert_trigger AFTER INSERT ON media
|
||||
BEGIN
|
||||
INSERT INTO playlist_properties (active, sort_order)
|
||||
VALUES (False, "mediumno, number");
|
||||
UPDATE media SET propertyid = last_insert_rowid()
|
||||
WHERE mediumid = NEW.mediumid;
|
||||
END;
|
||||
|
||||
CREATE TRIGGER media_delete_trigger AFTER DELETE ON media
|
||||
BEGIN
|
||||
DELETE FROM playlist_properties WHERE propertyid = OLD.propertyid;
|
||||
END;
|
||||
|
||||
|
||||
/*******************************************************
|
||||
* *
|
||||
* Artist <--> Album <--> Medium Linking *
|
||||
* *
|
||||
*******************************************************/
|
||||
|
||||
CREATE TABLE album_artist_link (
|
||||
artistid INTEGER NOT NULL REFERENCES artists (artistid)
|
||||
ON DELETE CASCADE
|
||||
ON UPDATE CASCADE,
|
||||
albumid INTEGER NOT NULL REFERENCES albums (albumid)
|
||||
ON DELETE CASCADE
|
||||
ON UPDATE CASCADE,
|
||||
UNIQUE (artistid, albumid)
|
||||
);
|
||||
|
||||
CREATE VIEW album_artist_view AS
|
||||
SELECT artistid, artists.name as artist,
|
||||
albumid, COALESCE(albums.name, "") as album,
|
||||
media.mediumid, COALESCE(media.name, "") as medium
|
||||
FROM artists
|
||||
LEFT JOIN album_artist_link USING (artistid)
|
||||
LEFT JOIN albums USING (albumid)
|
||||
LEFT JOIN media USING (albumid);
|
||||
|
||||
|
||||
/************************
|
||||
* *
|
||||
* Genres *
|
||||
* *
|
||||
************************/
|
||||
|
||||
CREATE TABLE genres (
|
||||
genreid INTEGER PRIMARY KEY,
|
||||
propertyid INTEGER REFERENCES playlist_properties (propertyid)
|
||||
ON DELETE CASCADE
|
||||
ON UPDATE CASCADE,
|
||||
name TEXT NOT NULL UNIQUE COLLATE NOCASE
|
||||
);
|
||||
|
||||
CREATE VIEW genres_view AS
|
||||
SELECT genreid, propertyid, name,
|
||||
active, loop, shuffle, sort_order, current_trackid
|
||||
FROM genres
|
||||
JOIN playlist_properties USING (propertyid);
|
||||
|
||||
CREATE TRIGGER genres_insert_trigger AFTER INSERT ON genres
|
||||
BEGIN
|
||||
INSERT INTO playlist_properties (active, sort_order)
|
||||
VALUES (False, "albumartist, album, mediumno, number");
|
||||
UPDATE genres SET propertyid = last_insert_rowid()
|
||||
WHERE genreid = NEW.genreid;
|
||||
END;
|
||||
|
||||
CREATE TRIGGER genres_delete_trigger AFTER DELETE ON genres
|
||||
BEGIN
|
||||
DELETE FROM playlist_properties WHERE propertyid = OLD.propertyid;
|
||||
END;
|
||||
|
||||
|
||||
/*************************
|
||||
* *
|
||||
* Decades *
|
||||
* *
|
||||
*************************/
|
||||
|
||||
CREATE TABLE decades (
|
||||
decade INTEGER PRIMARY KEY,
|
||||
propertyid INTEGER REFERENCES playlist_properties (propertyid)
|
||||
ON DELETE CASCADE
|
||||
ON UPDATE CASCADE
|
||||
CHECK (decade % 10 = 0)
|
||||
);
|
||||
|
||||
CREATE VIEW decades_view AS
|
||||
SELECT decade, propertyid, FORMAT("The %ds", decade) as name,
|
||||
active, loop, shuffle, sort_order, current_trackid
|
||||
FROM decades
|
||||
JOIN playlist_properties USING (propertyid);
|
||||
|
||||
CREATE TRIGGER decades_insert_trigger AFTER INSERT ON decades
|
||||
BEGIN
|
||||
INSERT INTO playlist_properties (active, sort_order)
|
||||
VALUES (False, "release, albumartist, album, mediumno, number");
|
||||
UPDATE decades SET propertyid = last_insert_rowid()
|
||||
WHERE decade = NEW.decade;
|
||||
END;
|
||||
|
||||
CREATE TRIGGER decades_delete_trigger AFTER DELETE ON decades
|
||||
BEGIN
|
||||
DELETE FROM playlist_properties WHERE propertyid = OLD.propertyid;
|
||||
END;
|
||||
|
||||
|
||||
/***********************
|
||||
* *
|
||||
* Years *
|
||||
* *
|
||||
***********************/
|
||||
|
||||
CREATE TABLE years (
|
||||
year INTEGER PRIMARY KEY,
|
||||
propertyid INTEGER REFERENCES playlist_properties (propertyid)
|
||||
ON DELETE CASCADE
|
||||
ON UPDATE CASCADE
|
||||
);
|
||||
|
||||
CREATE VIEW years_view AS
|
||||
SELECT year, propertyid, FORMAT("%s", year) as name,
|
||||
active, loop, shuffle, sort_order, current_trackid
|
||||
FROM years
|
||||
JOIN playlist_properties USING (propertyid);
|
||||
|
||||
CREATE TRIGGER years_insert_trigger AFTER INSERT ON years
|
||||
BEGIN
|
||||
INSERT INTO playlist_properties (active, sort_order)
|
||||
VALUES (False, "release, albumartist, album, mediumno, number");
|
||||
UPDATE years SET propertyid = last_insert_rowid()
|
||||
WHERE year = NEW.year;
|
||||
END;
|
||||
|
||||
CREATE TRIGGER years_delete_trigger AFTER DELETE ON years
|
||||
BEGIN
|
||||
DELETE FROM playlist_properties WHERE propertyid = OLD.propertyid;
|
||||
END;
|
||||
|
||||
|
||||
/*******************************
|
||||
* *
|
||||
* Library Paths *
|
||||
* *
|
||||
*******************************/
|
||||
|
||||
CREATE TABLE libraries (
|
||||
libraryid INTEGER PRIMARY KEY,
|
||||
propertyid INTEGER REFERENCES playlist_properties (propertyid)
|
||||
ON DELETE CASCADE
|
||||
ON UPDATE CASCADE,
|
||||
path PATH UNIQUE,
|
||||
enabled BOOLEAN DEFAULT TRUE,
|
||||
deleting BOOLEAN DEFAULT FALSE
|
||||
);
|
||||
|
||||
CREATE VIEW libraries_view AS
|
||||
SELECT libraryid, propertyid, path, path as name, enabled,
|
||||
active, loop, shuffle, sort_order, current_trackid
|
||||
FROM libraries
|
||||
JOIN playlist_properties USING (propertyid);
|
||||
|
||||
CREATE TRIGGER libraries_insert_trigger AFTER INSERT ON libraries
|
||||
BEGIN
|
||||
INSERT INTO playlist_properties (active, sort_order)
|
||||
VALUES (False, "filepath");
|
||||
UPDATE libraries SET propertyid = last_insert_rowid()
|
||||
WHERE libraryid = NEW.libraryid;
|
||||
END;
|
||||
|
||||
CREATE TRIGGER libraries_delete_trigger AFTER DELETE ON libraries
|
||||
BEGIN
|
||||
DELETE FROM playlist_properties WHERE propertyid = OLD.propertyid;
|
||||
END;
|
||||
|
||||
|
||||
/************************
|
||||
* *
|
||||
* Tracks *
|
||||
* *
|
||||
************************/
|
||||
|
||||
CREATE TABLE tracks (
|
||||
trackid INTEGER PRIMARY KEY,
|
||||
libraryid INTEGER REFERENCES libraries (libraryid)
|
||||
ON DELETE CASCADE
|
||||
ON UPDATE CASCADE,
|
||||
mediumid INTEGER REFERENCES media (mediumid)
|
||||
ON DELETE CASCADE
|
||||
ON UPDATE CASCADE,
|
||||
year INTEGER REFERENCES years (year)
|
||||
ON DELETE CASCADE
|
||||
ON UPDATE CASCADE,
|
||||
path PATH NOT NULL,
|
||||
mbid TEXT NOT NULL DEFAULT "" COLLATE NOCASE,
|
||||
title TEXT NOT NULL,
|
||||
number INTEGER NOT NULL,
|
||||
length REAL NOT NULL,
|
||||
artist TEXT NOT NULL,
|
||||
mtime REAL NOT NULL,
|
||||
active BOOLEAN NOT NULL DEFAULT FALSE,
|
||||
favorite BOOLEAN NOT NULL DEFAULT FALSE,
|
||||
playcount INTEGER NOT NULL DEFAULT 0,
|
||||
added DATE DEFAULT CURRENT_DATE,
|
||||
laststarted TIMESTAMP,
|
||||
lastplayed TIMESTAMP,
|
||||
UNIQUE (libraryid, path)
|
||||
);
|
||||
|
||||
CREATE VIEW track_info_view AS
|
||||
SELECT trackid, tracks.mediumid, tracks.number, length, playcount,
|
||||
laststarted, lastplayed, title, tracks.artist,
|
||||
tracks.path as filepath,
|
||||
media.number as mediumno, COALESCE(media.name, "") as medium,
|
||||
albums.albumid, COALESCE(albums.name, "") as album,
|
||||
COALESCE(albums.release, "") as release,
|
||||
COALESCE(albums.artist, "") as albumartist,
|
||||
libraries.deleting
|
||||
FROM tracks
|
||||
LEFT JOIN media USING (mediumid)
|
||||
LEFT JOIN albums USING (albumid)
|
||||
LEFT JOIN libraries USING (libraryid);
|
||||
|
||||
CREATE TRIGGER tracks_active_trigger
|
||||
AFTER UPDATE OF active ON tracks
|
||||
FOR EACH ROW BEGIN
|
||||
UPDATE tracks
|
||||
SET active = FALSE
|
||||
WHERE trackid != NEW.trackid and active == TRUE;
|
||||
END;
|
||||
|
||||
|
||||
/*********************************************
|
||||
* *
|
||||
* Track <--> Playlist Linking *
|
||||
* *
|
||||
*********************************************/
|
||||
|
||||
CREATE TABLE system_tracks (
|
||||
trackid INTEGER REFERENCES tracks (trackid)
|
||||
ON DELETE CASCADE
|
||||
ON UPDATE CASCADE,
|
||||
propertyid INTEGER REFERENCES playlist_properties (propertyid)
|
||||
ON DELETE CASCADE
|
||||
ON UPDATE CASCADE,
|
||||
UNIQUE(trackid, propertyid)
|
||||
);
|
||||
|
||||
CREATE TABLE user_tracks (
|
||||
trackid INTEGER REFERENCES tracks (trackid)
|
||||
ON DELETE CASCADE
|
||||
ON DELETE CASCADE,
|
||||
propertyid INTEGER REFERENCES playlist_properties (propertyid)
|
||||
ON DELETE CASCADE
|
||||
ON UPDATE CASCADE,
|
||||
position INTEGER,
|
||||
UNIQUE(trackid, propertyid)
|
||||
);
|
||||
|
||||
CREATE VIEW system_tracks_view AS
|
||||
SELECT trackid, system_tracks.propertyid
|
||||
FROM system_tracks
|
||||
JOIN tracks USING (trackid)
|
||||
JOIN libraries USING (libraryid)
|
||||
WHERE libraries.deleting = FALSE;
|
||||
|
||||
CREATE VIEW user_tracks_view AS
|
||||
SELECT trackid, user_tracks.propertyid, user_tracks.position
|
||||
FROM user_tracks
|
||||
JOIN tracks USING (trackid)
|
||||
JOIN libraries USING (libraryid)
|
||||
WHERE libraries.deleting = FALSE;
|
||||
|
||||
CREATE VIEW collection_view AS
|
||||
SELECT tracks.trackid FROM tracks
|
||||
JOIN libraries USING (libraryid)
|
||||
WHERE libraries.enabled = TRUE AND libraries.deleting = FALSE;
|
||||
|
||||
CREATE VIEW favorite_view AS
|
||||
SELECT tracks.trackid FROM tracks
|
||||
JOIN libraries USING (libraryid)
|
||||
WHERE tracks.favorite = TRUE AND libraries.deleting = FALSE;
|
||||
|
||||
CREATE VIEW most_played_view AS
|
||||
SELECT tracks.trackid FROM tracks
|
||||
JOIN libraries USING (libraryid)
|
||||
WHERE tracks.playcount > (SELECT CEIL(AVG(playcount))
|
||||
FROM tracks WHERE playcount>0)
|
||||
AND libraries.deleting = FALSE;
|
||||
|
||||
CREATE VIEW new_tracks_view AS
|
||||
SELECT tracks.trackid FROM tracks
|
||||
JOIN libraries USING (libraryid)
|
||||
WHERE tracks.added > DATE('now', 'localtime', '-7 days')
|
||||
AND libraries.deleting = FALSE;
|
||||
|
||||
CREATE VIEW unplayed_tracks_view AS
|
||||
SELECT tracks.trackid FROM tracks
|
||||
JOIN libraries USING (libraryid)
|
||||
WHERE tracks.playcount == 0 AND libraries.deleting = FALSE;
|
||||
|
||||
CREATE VIEW artist_tracks_view AS
|
||||
SELECT tracks.trackid, artists.artistid
|
||||
FROM tracks
|
||||
JOIN system_tracks USING (trackid)
|
||||
JOIN artists USING (propertyid)
|
||||
JOIN libraries USING (libraryid)
|
||||
WHERE libraries.deleting = False;
|
||||
|
||||
CREATE VIEW album_tracks_view AS
|
||||
SELECT tracks.trackid, albums.albumid
|
||||
FROM tracks
|
||||
JOIN media USING (mediumid)
|
||||
JOIN albums USING (albumid)
|
||||
JOIN libraries USING (libraryid)
|
||||
WHERE libraries.deleting = False;
|
||||
|
||||
CREATE VIEW medium_tracks_view AS
|
||||
SELECT tracks.trackid, media.mediumid
|
||||
FROM tracks
|
||||
JOIN media USING (mediumid)
|
||||
JOIN libraries USING (libraryid)
|
||||
WHERE libraries.deleting = False;
|
||||
|
||||
CREATE VIEW genre_tracks_view AS
|
||||
SELECT tracks.trackid, genres.genreid
|
||||
FROM tracks
|
||||
JOIN system_tracks USING (trackid)
|
||||
JOIN genres USING (propertyid)
|
||||
JOIN libraries USING (libraryid)
|
||||
WHERE libraries.deleting = False;
|
||||
|
||||
CREATE VIEW decade_tracks_view AS
|
||||
SELECT tracks.trackid, decades.decade
|
||||
FROM tracks
|
||||
JOIN decades ON (tracks.year / 10 * 10) = decades.decade
|
||||
JOIN libraries USING (libraryid)
|
||||
WHERE libraries.deleting = False;
|
||||
|
||||
CREATE VIEW year_tracks_view AS
|
||||
SELECT tracks.trackid, years.year
|
||||
FROM tracks
|
||||
JOIN years USING (year)
|
||||
JOIN libraries USING (libraryid)
|
||||
WHERE libraries.deleting = False;
|
||||
|
||||
CREATE VIEW library_tracks_view AS
|
||||
SELECT tracks.trackid, libraries.libraryid
|
||||
FROM tracks
|
||||
JOIN libraries USING (libraryid)
|
||||
WHERE libraries.deleting = False;
|
||||
|
||||
|
||||
/****************************************************
|
||||
* *
|
||||
* Data saved when Tracks are deleted *
|
||||
* *
|
||||
****************************************************/
|
||||
|
||||
CREATE TABLE saved_track_data (
|
||||
mbid TEXT PRIMARY KEY,
|
||||
favorite BOOLEAN NOT NULL DEFAULT FALSE,
|
||||
playcount INTEGER NOT NULL DEFAULT 0,
|
||||
lastplayed TIMESTAMP DEFAULT NULL,
|
||||
laststarted TIMESTAMP DEFAULT NULL
|
||||
);
|
||||
|
||||
CREATE TRIGGER tracks_delete_save BEFORE DELETE ON tracks
|
||||
WHEN OLD.mbid != "" BEGIN
|
||||
INSERT INTO saved_track_data
|
||||
(mbid, favorite, playcount, lastplayed, laststarted)
|
||||
VALUES (OLD.mbid, OLD.favorite, OLD.playcount,
|
||||
OLD.lastplayed, OLD.laststarted);
|
||||
END;
|
||||
|
||||
CREATE TRIGGER tracks_insert_restore AFTER INSERT ON tracks
|
||||
WHEN NEW.mbid != "" BEGIN
|
||||
UPDATE tracks SET favorite = saved_track_data.favorite,
|
||||
playcount = saved_track_data.playcount,
|
||||
lastplayed = saved_track_data.lastplayed,
|
||||
laststarted = saved_track_data.laststarted
|
||||
FROM saved_track_data
|
||||
WHERE tracks.mbid = saved_track_data.mbid AND
|
||||
tracks.mbid = NEW.mbid;
|
||||
DELETE FROM saved_track_data WHERE mbid = NEW.mbid;
|
||||
END;
|
||||
|
||||
|
||||
/******************************************
|
||||
* *
|
||||
* Create Default Playlists *
|
||||
* *
|
||||
******************************************/
|
||||
|
||||
INSERT INTO playlists (name) VALUES
|
||||
("Collection"),
|
||||
("Favorite Tracks"),
|
||||
("Most Played Tracks"),
|
||||
("New Tracks"),
|
||||
("Previous Tracks"),
|
||||
("Queued Tracks"),
|
||||
("Unplayed Tracks");
|
|
@ -0,0 +1,63 @@
|
|||
# Copyright 2022 (c) Anna Schumaker
|
||||
"""A custom Gio.ListModel for genres."""
|
||||
import sqlite3
|
||||
from gi.repository import GObject
|
||||
from .. import format
|
||||
from . import playlist
|
||||
|
||||
|
||||
class Genre(playlist.Playlist):
|
||||
"""Our custom Genre object representing a single genre."""
|
||||
|
||||
genreid = GObject.Property(type=int)
|
||||
|
||||
@property
|
||||
def primary_key(self) -> int:
|
||||
"""Get this Gener's primary key."""
|
||||
return self.genreid
|
||||
|
||||
|
||||
class Table(playlist.Table):
|
||||
"""Our Genre Table."""
|
||||
|
||||
def __init__(self, sql: GObject.TYPE_PYOBJECT, **kwargs):
|
||||
"""Initialize the Genres Table."""
|
||||
super().__init__(sql=sql, autodelete=True, **kwargs)
|
||||
|
||||
def do_construct(self, **kwargs) -> Genre:
|
||||
"""Construct a new Genre."""
|
||||
return Genre(**kwargs)
|
||||
|
||||
def do_get_sort_key(self, genre: Genre) -> tuple[tuple[str], int]:
|
||||
"""Get a sort key for the Genre."""
|
||||
return (format.sort_key(genre.name), genre.genreid)
|
||||
|
||||
def do_sql_delete(self, genre: Genre) -> sqlite3.Cursor:
|
||||
"""Delete a genre."""
|
||||
return self.sql("DELETE FROM genres WHERE genreid=?", genre.genreid)
|
||||
|
||||
def do_sql_glob(self, glob: str) -> sqlite3.Cursor:
|
||||
"""Search for genres matching the search text."""
|
||||
return self.sql("""SELECT genreid FROM genres
|
||||
WHERE CASEFOLD(name) GLOB ?""", glob)
|
||||
|
||||
def do_sql_insert(self, name: str) -> sqlite3.Cursor | None:
|
||||
"""Create a new genre."""
|
||||
if cur := self.sql("INSERT INTO genres (name) VALUES (?)", name):
|
||||
return self.sql("SELECT * FROM genres_view WHERE genreid=?",
|
||||
cur.lastrowid)
|
||||
|
||||
def do_sql_select_all(self) -> sqlite3.Cursor:
|
||||
"""Load genres from the database."""
|
||||
return self.sql("SELECT * FROM genres_view")
|
||||
|
||||
def do_sql_select_one(self, name: str) -> sqlite3.Cursor:
|
||||
"""Look up a genre by name."""
|
||||
return self.sql("SELECT genreid FROM genres WHERE CASEFOLD(name)=?",
|
||||
name.casefold())
|
||||
|
||||
def do_sql_update(self, genre: playlist.Playlist,
|
||||
column: str, newval) -> sqlite3.Cursor:
|
||||
"""Update a genre."""
|
||||
return self.sql(f"UPDATE genres SET {column}=? WHERE genreid=?",
|
||||
newval, genre.genreid)
|
|
@ -0,0 +1,94 @@
|
|||
# Copyright 2022 (c) Anna Schumaker
|
||||
"""Idle queues to assid with large database operations."""
|
||||
import typing
|
||||
from gi.repository import GObject
|
||||
from gi.repository import GLib
|
||||
|
||||
|
||||
class Queue(GObject.GObject):
|
||||
"""A base class Idle Queue."""
|
||||
|
||||
total = GObject.Property(type=int)
|
||||
progress = GObject.Property(type=float)
|
||||
running = GObject.Property(type=bool, default=False)
|
||||
enabled = GObject.Property(type=bool, default=True)
|
||||
|
||||
def __init__(self, **kwargs):
|
||||
"""Initialize an Idle Queue."""
|
||||
super().__init__(**kwargs)
|
||||
self._tasks = []
|
||||
self._idle_id = None
|
||||
|
||||
def __getitem__(self, n: int) -> tuple:
|
||||
"""Get the n-th task in the queue."""
|
||||
return self._tasks[n] if n < len(self._tasks) else None
|
||||
|
||||
def __run_next_task(self) -> None:
|
||||
task = self._tasks[0]
|
||||
if task[0](*task[1:]):
|
||||
self._tasks.pop(0)
|
||||
|
||||
def __start(self) -> None:
|
||||
if not self.running:
|
||||
self.running = True
|
||||
self._idle_id = GLib.idle_add(self.run_task)
|
||||
self.__update_counters()
|
||||
|
||||
def __update_counters(self) -> bool:
|
||||
if (pending := len(self._tasks)) == 0:
|
||||
self.cancel()
|
||||
return GLib.SOURCE_REMOVE
|
||||
self.progress = 1 - (pending / self.total)
|
||||
return GLib.SOURCE_CONTINUE
|
||||
|
||||
def cancel(self) -> None:
|
||||
"""Cancel all pending tasks."""
|
||||
if self._idle_id is not None:
|
||||
GLib.source_remove(self._idle_id)
|
||||
|
||||
self._tasks.clear()
|
||||
self.progress = 0.0
|
||||
self.total = 0
|
||||
self.running = False
|
||||
self._idle_id = None
|
||||
|
||||
def cancel_task(self, func: typing.Callable) -> None:
|
||||
"""Remove all instances of a specific task from the Idle Queue."""
|
||||
self._tasks = [t for t in self._tasks if t[0] != func]
|
||||
self.__update_counters()
|
||||
|
||||
def complete(self) -> None:
|
||||
"""Complete all pending tasks."""
|
||||
if self.running:
|
||||
while len(self._tasks) > 0:
|
||||
self.__run_next_task()
|
||||
self.cancel()
|
||||
|
||||
def push(self, func: typing.Callable, *args,
|
||||
now: bool = False, first: bool = False) -> bool | None:
|
||||
"""Add a task to the Idle Queue."""
|
||||
if not self.enabled or now:
|
||||
return func(*args)
|
||||
|
||||
pos = 0 if first else len(self._tasks)
|
||||
self._tasks.insert(pos, (func, *args))
|
||||
self.total += 1
|
||||
self.__start()
|
||||
|
||||
def push_many(self, func: typing.Callable, args: list[tuple[any]],
|
||||
now: bool = False) -> None:
|
||||
"""Add several tasks to the Idle Queue."""
|
||||
if not self.enabled or now:
|
||||
for arg in args:
|
||||
func(*arg)
|
||||
else:
|
||||
self._tasks.extend([(func, *arg) for arg in args])
|
||||
self.total += len(args)
|
||||
self.__start()
|
||||
|
||||
def run_task(self) -> bool:
|
||||
"""Manually run the next task."""
|
||||
if len(self._tasks) > 0:
|
||||
self.__run_next_task()
|
||||
return self.__update_counters()
|
||||
return GLib.SOURCE_REMOVE
|
|
@ -0,0 +1,192 @@
|
|||
# Copyright 2022 (c) Anna Schumaker
|
||||
"""A custom Gio.ListModel for working with libraries."""
|
||||
import pathlib
|
||||
import sqlite3
|
||||
from gi.repository import GObject
|
||||
from .. import path
|
||||
from . import idle
|
||||
from . import playlist
|
||||
from . import tagger
|
||||
from . import tracks
|
||||
|
||||
|
||||
class Library(playlist.Playlist):
|
||||
"""Our custom Library with path and enabled properties."""
|
||||
|
||||
libraryid = GObject.Property(type=int)
|
||||
path = GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
enabled = GObject.Property(type=bool, default=True)
|
||||
deleting = GObject.Property(type=bool, default=False)
|
||||
|
||||
queue = GObject.Property(type=idle.Queue)
|
||||
readdir = GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
tagger = GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
online = GObject.Property(type=bool, default=False)
|
||||
|
||||
def __init__(self, **kwargs):
|
||||
"""Initialize our Library object."""
|
||||
super().__init__(queue=idle.Queue(), **kwargs)
|
||||
self.scan()
|
||||
|
||||
def __check_trackid(self, trackid: int) -> bool:
|
||||
track = self.table.sql.tracks.rows.get(trackid)
|
||||
if track is not None and not track.path.exists():
|
||||
tagger.untag_track(self.table.sql, track)
|
||||
track.delete()
|
||||
return True
|
||||
|
||||
def __queue_delete(self) -> bool:
|
||||
self.table.delete(self)
|
||||
self.table.sql.tracks.load()
|
||||
return True
|
||||
|
||||
def __queue_tracks(self) -> bool:
|
||||
if (files := self.readdir.poll_result()) is None:
|
||||
self.__stop_thread("readdir")
|
||||
self.queue.push(self.__stop_thread, "tagger")
|
||||
return True
|
||||
|
||||
self.queue.push_many(self.__tag_track, [(f,) for f in files])
|
||||
return False
|
||||
|
||||
def __reload_playlist_tracks(self, playlist: playlist.Playlist) -> bool:
|
||||
playlist.reload_tracks(idle=False)
|
||||
return True
|
||||
|
||||
def __tag_track(self, path: pathlib.Path) -> bool:
|
||||
if self.tagger.ready.is_set():
|
||||
result = self.tagger.get_result(db=self.table.sql, library=self)
|
||||
if result is None:
|
||||
track = self.table.sql.tracks.lookup(self, path=path)
|
||||
mtime = track.mtime if track else None
|
||||
self.tagger.tag_file(path, mtime=mtime)
|
||||
else:
|
||||
return True
|
||||
return False
|
||||
|
||||
def __scan_library(self) -> bool:
|
||||
self.readdir = path.readdir_async(self.path)
|
||||
if self.readdir is not None:
|
||||
self.online = True
|
||||
self.load_tracks()
|
||||
self.queue.push_many(self.__check_trackid,
|
||||
[(tid,) for tid in self.tracks.trackids])
|
||||
self.queue.push(self.__queue_tracks)
|
||||
self.tagger = tagger.Thread()
|
||||
return True
|
||||
|
||||
def __stop_thread(self, thread_name: str) -> bool:
|
||||
if (thread := self.get_property(thread_name)) is not None:
|
||||
thread.stop()
|
||||
self.set_property(thread_name, None)
|
||||
return True
|
||||
|
||||
def do_update(self, column: str) -> bool:
|
||||
"""Update a Library playlist."""
|
||||
match column:
|
||||
case "readdir" | "tagger": pass
|
||||
case "online": self.table.notify_online(self)
|
||||
case _: return super().do_update(column)
|
||||
return True
|
||||
|
||||
def delete(self) -> bool:
|
||||
"""Delete this Library."""
|
||||
if self.deleting is False:
|
||||
self.stop()
|
||||
self.deleting = True
|
||||
|
||||
self.table.sql.tracks.clear()
|
||||
for tbl in self.table.sql.playlist_tables():
|
||||
if tbl is not self:
|
||||
self.queue.push_many(self.__reload_playlist_tracks,
|
||||
[(plist,) for plist in tbl.store])
|
||||
self.queue.push(self.__queue_delete)
|
||||
return True
|
||||
return False
|
||||
|
||||
def scan(self) -> None:
|
||||
"""Scan the Library."""
|
||||
if not self.queue.running:
|
||||
self.queue.push(self.__scan_library)
|
||||
|
||||
def stop(self) -> None:
|
||||
"""Stop this Library's background work."""
|
||||
self.__stop_thread("readdir")
|
||||
self.__stop_thread("tagger")
|
||||
self.queue.cancel()
|
||||
|
||||
@property
|
||||
def primary_key(self) -> int:
|
||||
"""Get this library's primary key."""
|
||||
return self.libraryid
|
||||
|
||||
|
||||
class Table(playlist.Table):
|
||||
"""Our Library ListModel."""
|
||||
|
||||
def __init__(self, sql: GObject.TYPE_PYOBJECT, **kwargs):
|
||||
"""Initialize the Libraries Table."""
|
||||
super().__init__(sql=sql, system_tracks=False, **kwargs)
|
||||
|
||||
def do_add_track(self, library: Library, track: tracks.Track) -> bool:
|
||||
"""Verify adding a Track to a Library playlist."""
|
||||
return track.get_library() == library
|
||||
|
||||
def do_construct(self, **kwargs) -> Library:
|
||||
"""Construct a new library."""
|
||||
return Library(**kwargs)
|
||||
|
||||
def do_remove_track(self, library: Library, track: tracks.Track) -> bool:
|
||||
"""Verify removing a Track from a Library playlist."""
|
||||
return True
|
||||
|
||||
def do_sql_delete(self, library: Library) -> sqlite3.Cursor:
|
||||
"""Delete a library."""
|
||||
return self.sql("DELETE FROM libraries WHERE libraryid=?",
|
||||
library.libraryid)
|
||||
|
||||
def do_sql_insert(self, path: pathlib.Path) -> sqlite3.Cursor:
|
||||
"""Create a new library."""
|
||||
if cur := self.sql("INSERT INTO libraries (path) VALUES (?)", path):
|
||||
return self.sql("SELECT * FROM libraries_view WHERE libraryid=?",
|
||||
cur.lastrowid)
|
||||
|
||||
def do_sql_glob(self, glob: str) -> sqlite3.Cursor:
|
||||
"""Search for libraries matching the search text."""
|
||||
return self.sql("""SELECT libraryid FROM libraries_view
|
||||
WHERE name GLOB ?""", glob)
|
||||
|
||||
def do_sql_select_all(self) -> sqlite3.Cursor:
|
||||
"""Load libraries from the database."""
|
||||
return self.sql("SELECT * FROM libraries_view")
|
||||
|
||||
def do_sql_select_one(self, path: pathlib.Path) -> sqlite3.Cursor:
|
||||
"""Look up a library by path."""
|
||||
return self.sql("SELECT libraryid FROM libraries WHERE path=?", path)
|
||||
|
||||
def do_sql_select_trackids(self, library: Library) -> sqlite3.Cursor:
|
||||
"""Load a Library's Tracks from the database."""
|
||||
return self.sql("""SELECT trackid FROM library_tracks_view
|
||||
WHERE libraryid=?""", library.libraryid)
|
||||
|
||||
def do_sql_update(self, library: Library, column: str, newval) -> bool:
|
||||
"""Update a Library playlist."""
|
||||
if column == "enabled" and self.sql.playlists.collection:
|
||||
self.sql.playlists.collection.reload_tracks(idle=True)
|
||||
return self.sql(f"UPDATE libraries SET {column}=? WHERE rowid=?",
|
||||
newval, library.libraryid)
|
||||
|
||||
def notify_online(self, library: Library) -> None:
|
||||
"""Notify that a library's online status has changed."""
|
||||
if not library.online or self.loaded:
|
||||
self.emit("library-online", library)
|
||||
|
||||
def stop(self) -> None:
|
||||
"""Stop any background work."""
|
||||
for library in self.store:
|
||||
library.stop()
|
||||
super().stop()
|
||||
|
||||
@GObject.Signal(arg_types=(Library,))
|
||||
def library_online(self, library: Library) -> None:
|
||||
"""Signal that a library online status has changed."""
|
|
@ -0,0 +1,135 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""A custom Gio.ListModel for managing individual media in an album."""
|
||||
import sqlite3
|
||||
from gi.repository import GObject
|
||||
from gi.repository import Gtk
|
||||
from .. import format
|
||||
from . import playlist
|
||||
from . import table
|
||||
from . import tracks
|
||||
|
||||
|
||||
class Medium(playlist.Playlist):
|
||||
"""Our custom Medium object representing a single disc in an album."""
|
||||
|
||||
mediumid = GObject.Property(type=int)
|
||||
albumid = GObject.Property(type=int)
|
||||
number = GObject.Property(type=int, default=1)
|
||||
type = GObject.Property(type=str)
|
||||
|
||||
def get_album(self) -> playlist.Playlist:
|
||||
"""Get this Medium's Album."""
|
||||
return self.table.sql.albums.rows.get(self.albumid)
|
||||
|
||||
def rename(self, new_name: str) -> bool:
|
||||
"""Rename this medium."""
|
||||
return self.table.rename(self, new_name)
|
||||
|
||||
@property
|
||||
def primary_key(self) -> int:
|
||||
"""Get this Medium's primary key."""
|
||||
return self.mediumid
|
||||
|
||||
@GObject.Property(type=playlist.Playlist)
|
||||
def parent(self) -> playlist.Playlist | None:
|
||||
"""Get this Medium's parent playlist."""
|
||||
return self.get_album()
|
||||
|
||||
|
||||
class Filter(table.KeySet):
|
||||
"""Custom filter to hide media with empty names."""
|
||||
|
||||
def do_get_strictness(self) -> Gtk.FilterMatch:
|
||||
"""Get the strictness of the filter."""
|
||||
if (res := super().do_get_strictness()) == Gtk.FilterMatch.ALL:
|
||||
res = Gtk.FilterMatch.SOME
|
||||
return res
|
||||
|
||||
def do_match(self, medium: Medium) -> bool:
|
||||
"""Check if the Medium matches the filter."""
|
||||
return len(medium.name) > 0 if super().do_match(medium) else False
|
||||
|
||||
|
||||
class Table(playlist.Table):
|
||||
"""Our Media Table."""
|
||||
|
||||
def __init__(self, sql: GObject.TYPE_PYOBJECT, **kwargs):
|
||||
"""Initialize the Media Table."""
|
||||
super().__init__(sql=sql, filter=Filter(), autodelete=True,
|
||||
system_tracks=False, **kwargs)
|
||||
|
||||
def do_construct(self, **kwargs) -> Medium:
|
||||
"""Construct a new medium."""
|
||||
return Medium(**kwargs)
|
||||
|
||||
def do_add_track(self, medium: Medium, track: tracks.Track) -> bool:
|
||||
"""Verify adding a Track to the Medium playlist."""
|
||||
return track.get_medium() == medium
|
||||
|
||||
def do_get_sort_key(self, medium: Medium) -> tuple[int, int, tuple, str]:
|
||||
"""Get the sort key for a medium."""
|
||||
return (medium.albumid, medium.number,
|
||||
format.sort_key(medium.name), medium.type)
|
||||
|
||||
def do_remove_track(self, medium: Medium, track: tracks.Track) -> bool:
|
||||
"""Verify removing a Track from the Medium playlist."""
|
||||
return True
|
||||
|
||||
def do_sql_delete(self, medium: Medium) -> sqlite3.Cursor:
|
||||
"""Delete a medium."""
|
||||
medium.get_album().remove_medium(medium)
|
||||
return self.sql("DELETE FROM media WHERE mediumid=?",
|
||||
medium.mediumid)
|
||||
|
||||
def do_sql_glob(self, glob: str) -> sqlite3.Cursor:
|
||||
"""Search for media names matching the search text."""
|
||||
return self.sql("""SELECT mediumid FROM media
|
||||
WHERE CASEFOLD(name) GLOB ?""", glob)
|
||||
|
||||
def do_sql_insert(self, album: playlist.Playlist, name: str,
|
||||
*, number: int, type: str = "") -> sqlite3.Cursor | None:
|
||||
"""Create a new medium."""
|
||||
if cur := self.sql("""INSERT INTO media (albumid, number, name, type)
|
||||
VALUES (?, ?, ?, ?)""",
|
||||
album.albumid, number, name, type):
|
||||
return self.sql("SELECT * FROM media_view WHERE mediumid=?",
|
||||
cur.lastrowid)
|
||||
|
||||
def do_sql_select_all(self) -> sqlite3.Cursor:
|
||||
"""Load media from the database."""
|
||||
return self.sql("SELECT * FROM media_view")
|
||||
|
||||
def do_sql_select_one(self, album: playlist.Playlist,
|
||||
*, number: int, type: str = "") -> sqlite3.Cursor:
|
||||
"""Look up a medium by album, number, and type."""
|
||||
return self.sql("""SELECT mediumid FROM media
|
||||
WHERE albumid=? AND number=? AND type=?""",
|
||||
album.albumid, number, type)
|
||||
|
||||
def do_sql_select_trackids(self, medium: Medium) -> sqlite3.Cursor:
|
||||
"""Load a Medium's Tracks from the database."""
|
||||
return self.sql("""SELECT trackid FROM medium_tracks_view
|
||||
WHERE mediumid=?""", medium.mediumid)
|
||||
|
||||
def do_sql_update(self, medium: Medium,
|
||||
column: str, newval) -> sqlite3.Cursor:
|
||||
"""Update a medium."""
|
||||
return self.sql(f"UPDATE media SET {column}=? WHERE mediumid=?",
|
||||
newval, medium.mediumid)
|
||||
|
||||
def create(self, album: playlist.Playlist,
|
||||
*args, **kwargs) -> Medium | None:
|
||||
"""Create a new Medium playlist."""
|
||||
if (medium := super().create(album, *args, **kwargs)) is not None:
|
||||
album.add_medium(medium)
|
||||
return medium
|
||||
|
||||
def rename(self, medium: Medium, new_name: str) -> bool:
|
||||
"""Rename a medium."""
|
||||
if (new_name := new_name.strip()) != medium.name:
|
||||
if self.update(medium, "name", new_name):
|
||||
self.store.remove(medium)
|
||||
medium.name = new_name
|
||||
self.store.append(medium)
|
||||
return True
|
||||
return False
|
|
@ -0,0 +1,309 @@
|
|||
# Copyright 2022 (c) Anna Schumaker
|
||||
"""A customized Gio.ListStore for tracking Playlist GObjects."""
|
||||
import sqlite3
|
||||
import typing
|
||||
from gi.repository import GObject
|
||||
from gi.repository import Gio
|
||||
from gi.repository import Gtk
|
||||
from .tracks import Track, TrackidSet
|
||||
from .. import format
|
||||
from . import table
|
||||
|
||||
|
||||
class Playlist(table.Row):
|
||||
"""Our shared Playlist Row object."""
|
||||
|
||||
propertyid = GObject.Property(type=int)
|
||||
|
||||
name = GObject.Property(type=str)
|
||||
active = GObject.Property(type=bool, default=False)
|
||||
|
||||
loop = GObject.Property(type=str, default="None")
|
||||
shuffle = GObject.Property(type=bool, default=False)
|
||||
sort_order = GObject.Property(type=str)
|
||||
|
||||
tracks = GObject.Property(type=TrackidSet)
|
||||
n_tracks = GObject.Property(type=int)
|
||||
user_tracks = GObject.Property(type=bool, default=False)
|
||||
tracks_loaded = GObject.Property(type=bool, default=False)
|
||||
tracks_movable = GObject.Property(type=bool, default=False)
|
||||
current_trackid = GObject.Property(type=int)
|
||||
|
||||
child_set = GObject.Property(type=table.TableSubset)
|
||||
children = GObject.Property(type=Gtk.FilterListModel)
|
||||
|
||||
def __init__(self, table: Gio.ListModel, propertyid: int,
|
||||
name: str, current_trackid: int | None = 0, **kwargs):
|
||||
"""Initialize a Playlist object."""
|
||||
current_trackid = 0 if current_trackid is None else current_trackid
|
||||
super().__init__(table=table, propertyid=propertyid, name=name,
|
||||
current_trackid=current_trackid,
|
||||
tracks=TrackidSet(), **kwargs)
|
||||
self.tracks.bind_property("n-trackids", self, "n-tracks")
|
||||
|
||||
def __add_track(self, track: Track) -> bool:
|
||||
self.tracks.add_track(track)
|
||||
return True
|
||||
|
||||
def __remove_track(self, track: Track) -> bool:
|
||||
self.tracks.remove_track(track)
|
||||
self.table.remove_track(self, track)
|
||||
return True
|
||||
|
||||
def add_children(self, child_table: table.Table, child_keys: set) -> None:
|
||||
"""Create a FilterListModel for this playlist's children."""
|
||||
self.child_set = table.TableSubset(child_table, keys=child_keys)
|
||||
self.children = Gtk.FilterListModel.new(self.child_set,
|
||||
child_table.get_filter())
|
||||
|
||||
def do_update(self, column: str) -> bool:
|
||||
"""Update a Playlist object."""
|
||||
match column:
|
||||
case "propertyid" | "name" | "n-tracks" | "child-set" | \
|
||||
"children" | "user-tracks" | "tracks-loaded" | \
|
||||
"tracks-movable": pass
|
||||
case _: return super().do_update(column)
|
||||
return True
|
||||
|
||||
def add_child(self, child: typing.Self) -> None:
|
||||
"""Add a child Playlist to this Playlist."""
|
||||
self.child_set.add_row(child)
|
||||
if self.child_set.keyset.n_keys == 1:
|
||||
self.table.refilter(Gtk.FilterChange.LESS_STRICT)
|
||||
|
||||
def add_track(self, track: Track, *, idle: bool = False) -> None:
|
||||
"""Add a Track to this Playlist."""
|
||||
if self.table.add_track(self, track):
|
||||
self.table.queue.push(self.__add_track, track, now=not idle)
|
||||
|
||||
def get_track_order(self) -> dict[int, int]:
|
||||
"""Get a dictionary mapping for trackid -> sorted position."""
|
||||
return self.table.get_track_order(self)
|
||||
|
||||
def has_child(self, child: typing.Self) -> bool:
|
||||
"""Check if this Playlist has a specific child Playlist."""
|
||||
return child in self.child_set
|
||||
|
||||
def has_track(self, track: Track) -> bool:
|
||||
"""Check if a Track is on this Playlist."""
|
||||
return track in self.tracks
|
||||
|
||||
def load_tracks(self) -> bool:
|
||||
"""Load this Playlist's Tracks (if they haven't been loaded yet)."""
|
||||
if not self.tracks_loaded:
|
||||
self.tracks.trackids = self.table.get_trackids(self)
|
||||
self.tracks_loaded = True
|
||||
return True
|
||||
|
||||
def move_track_down(self, track: Track) -> bool:
|
||||
"""Move a track down in the sort order."""
|
||||
return self.table.move_track_down(self, track)
|
||||
|
||||
def move_track_up(self, track: Track) -> bool:
|
||||
"""Move a track up in the sort order."""
|
||||
return self.table.move_track_up(self, track)
|
||||
|
||||
def reload_tracks(self, *, idle: bool = False) -> None:
|
||||
"""Load this Playlist's Tracks."""
|
||||
self.tracks_loaded = False
|
||||
self.table.queue.push(self.load_tracks, now=not idle)
|
||||
|
||||
def remove_child(self, child: typing.Self) -> None:
|
||||
"""Remove a child Playlist from this Playlist."""
|
||||
self.child_set.remove_row(child)
|
||||
if self.child_set.keyset.n_keys == 0:
|
||||
self.table.refilter(Gtk.FilterChange.MORE_STRICT)
|
||||
|
||||
def remove_track(self, track: table.Row, *, idle: bool = False) -> None:
|
||||
"""Remove a Track from this Playlist."""
|
||||
self.table.queue.push(self.__remove_track, track, now=not idle)
|
||||
|
||||
def rename(self, new_name: str) -> bool:
|
||||
"""Rename this playlist."""
|
||||
return self.table.rename(self, new_name)
|
||||
|
||||
@GObject.Property(type=table.Row)
|
||||
def parent(self) -> table.Row | None:
|
||||
"""Get this playlist's parent playlist."""
|
||||
return None
|
||||
|
||||
|
||||
class Table(table.Table):
|
||||
"""A table.Table with extra functionality for Playlists."""
|
||||
|
||||
active_playlist = GObject.Property(type=Playlist)
|
||||
treemodel = GObject.Property(type=Gtk.TreeListModel)
|
||||
|
||||
autodelete = GObject.Property(type=bool, default=False)
|
||||
system_tracks = GObject.Property(type=bool, default=True)
|
||||
|
||||
def __init__(self, sql: GObject.TYPE_PYOBJECT, **kwargs):
|
||||
"""Initialize a Playlist Table."""
|
||||
super().__init__(sql=sql, **kwargs)
|
||||
self.treemodel = Gtk.TreeListModel.new(root=self,
|
||||
passthrough=False,
|
||||
autoexpand=False,
|
||||
create_func=self.__create_tree)
|
||||
|
||||
def __do_autodelete(self, plist: Playlist) -> bool:
|
||||
if plist.n_tracks == 0:
|
||||
self.delete(plist)
|
||||
return True
|
||||
|
||||
def __autodelete(self, plist: Playlist):
|
||||
if self.autodelete:
|
||||
self.queue.push(self.__do_autodelete, plist)
|
||||
|
||||
def __create_tree(self, plist: Playlist) -> Gtk.FilterListModel | None:
|
||||
return plist.children
|
||||
|
||||
def __refilter(self, change_how: Gtk.FilterChange) -> bool:
|
||||
self.get_filter().changed(change_how)
|
||||
return True
|
||||
|
||||
def do_add_track(self, playlist: Playlist, track: Track) -> bool:
|
||||
"""Add a Track to the Playlist."""
|
||||
raise NotImplementedError
|
||||
|
||||
def do_get_sort_key(self, playlist: Playlist) -> tuple[str]:
|
||||
"""Get a sort key for the requested Playlist."""
|
||||
return format.sort_key(playlist.name)
|
||||
|
||||
def do_get_user_track_order(self, playlist: Playlist) -> dict[int, int]:
|
||||
"""Get a mapping of sort keys for the tracks in this Playlist."""
|
||||
raise NotImplementedError
|
||||
|
||||
def do_move_track_down(self, playlist: Playlist, track: Track) -> bool:
|
||||
"""Move a track down in the sort order."""
|
||||
raise NotImplementedError
|
||||
|
||||
def do_move_track_up(self, playlist: Playlist, track: Track) -> bool:
|
||||
"""Move a track up in the sort order."""
|
||||
raise NotImplementedError
|
||||
|
||||
def do_remove_track(self, playlist: Playlist, track: Track) -> bool:
|
||||
"""Remove a Track from the Playlist."""
|
||||
raise NotImplementedError
|
||||
|
||||
def do_sql_select_trackids(self, playlist: Playlist) -> sqlite3.Cursor:
|
||||
"""Select the trackids that are in this Playlist."""
|
||||
raise NotImplementedError
|
||||
|
||||
def add_system_track(self, playlist: Playlist, track: Track) -> bool:
|
||||
"""Add a Track to a system Playlist."""
|
||||
cur = self.sql("""INSERT INTO system_tracks (propertyid, trackid)
|
||||
VALUES (?, ?)""", playlist.propertyid, track.trackid)
|
||||
return cur and cur.rowcount == 1
|
||||
|
||||
def add_track(self, playlist: Playlist, track: Track) -> bool:
|
||||
"""Add a Track to a Playlist."""
|
||||
if track is None or track.get_library().deleting:
|
||||
return False
|
||||
if self.system_tracks:
|
||||
return self.add_system_track(playlist, track)
|
||||
return self.do_add_track(playlist, track)
|
||||
|
||||
def clear(self) -> None:
|
||||
"""Clear the Table."""
|
||||
self.active_playlist = None
|
||||
super().clear()
|
||||
|
||||
def construct(self, propertyid: int, name: str, **kwargs) -> Playlist:
|
||||
"""Construct a new Playlist object."""
|
||||
res = super().construct(propertyid=propertyid, name=name, **kwargs)
|
||||
if res.active:
|
||||
self.sql.set_active_playlist(res)
|
||||
res.reload_tracks(idle=True)
|
||||
return res
|
||||
|
||||
def delete(self, playlist: Playlist) -> bool:
|
||||
"""Delete a playlist from the database."""
|
||||
if playlist.active:
|
||||
self.sql.set_active_playlist(None)
|
||||
return super().delete(playlist)
|
||||
|
||||
def get_sql_system_trackids(self, playlist: Playlist) -> sqlite3.Cursor:
|
||||
"""Load a System Playlist's Tracks from the database."""
|
||||
return self.sql("""SELECT trackid FROM system_tracks_view
|
||||
WHERE propertyid=?""", playlist.propertyid)
|
||||
|
||||
def get_trackids(self, playlist: Playlist) -> set[int]:
|
||||
"""Load a Playlist's Tracks from the database."""
|
||||
if self.system_tracks:
|
||||
cur = self.get_sql_system_trackids(playlist)
|
||||
else:
|
||||
cur = self.do_sql_select_trackids(playlist)
|
||||
|
||||
res = {row["trackid"] for row in cur.fetchall()}
|
||||
self.__autodelete(playlist)
|
||||
return res
|
||||
|
||||
def get_track_order(self, playlist: Playlist) -> dict[int, int]:
|
||||
"""Get the track sort order for a playlist."""
|
||||
if playlist.tracks_movable and playlist.sort_order == "user":
|
||||
return self.do_get_user_track_order(playlist)
|
||||
return self.sql.tracks.map_sort_order(playlist.sort_order)
|
||||
|
||||
def move_track_down(self, playlist: Playlist, track: Track) -> bool:
|
||||
"""Move a track down in the playlist."""
|
||||
if not playlist.tracks_movable:
|
||||
return False
|
||||
if res := self.do_move_track_down(playlist, track):
|
||||
if playlist.sort_order != "user":
|
||||
playlist.sort_order = "user"
|
||||
return res
|
||||
|
||||
def move_track_up(self, playlist: Playlist, track: Track) -> bool:
|
||||
"""Move a track up in the playlist."""
|
||||
if not playlist.tracks_movable:
|
||||
return False
|
||||
if res := self.do_move_track_up(playlist, track):
|
||||
if playlist.sort_order != "user":
|
||||
playlist.sort_order = "user"
|
||||
return res
|
||||
|
||||
def refilter(self, change_how: Gtk.FilterChange) -> None:
|
||||
"""Schedule refiltering the Table."""
|
||||
self.queue.cancel_task(self.__refilter)
|
||||
self.queue.push(self.__refilter, change_how, first=True)
|
||||
|
||||
def remove_system_track(self, playlist: Playlist, track: Track) -> bool:
|
||||
"""Remove a Track from a system Playlist."""
|
||||
return self.sql("""DELETE FROM system_tracks
|
||||
WHERE propertyid=? AND trackid=?""",
|
||||
playlist.propertyid, track.trackid).rowcount == 1
|
||||
|
||||
def remove_track(self, playlist: Playlist, track: Track) -> bool:
|
||||
"""Remove a Track from a Playlist."""
|
||||
if self.system_tracks:
|
||||
res = self.remove_system_track(playlist, track)
|
||||
else:
|
||||
res = self.do_remove_track(playlist, track)
|
||||
|
||||
self.__autodelete(playlist)
|
||||
return res
|
||||
|
||||
def update(self, playlist: Playlist, column: str, newval) -> bool:
|
||||
"""Update a Playlist in the Database."""
|
||||
match column:
|
||||
case "active" | "loop" | "shuffle" | \
|
||||
"sort-order" | "current-trackid":
|
||||
return self.update_playlist_property(playlist, column, newval)
|
||||
case _:
|
||||
return super().update(playlist, column, newval)
|
||||
|
||||
def update_playlist_property(self, playlist: Playlist,
|
||||
column: str, newval) -> bool:
|
||||
"""Update the playlists_common table."""
|
||||
match column:
|
||||
case "active":
|
||||
self.active_playlist = playlist if playlist.active else None
|
||||
case "current-trackid":
|
||||
column = "current_trackid"
|
||||
newval = None if newval == 0 else newval
|
||||
case "sort-order":
|
||||
column = "sort_order"
|
||||
|
||||
return self.sql(f"""UPDATE playlist_properties
|
||||
SET {column}=? WHERE propertyid=?""",
|
||||
newval, playlist.propertyid) is not None
|
|
@ -0,0 +1,237 @@
|
|||
# Copyright 2022 (c) Anna Schumaker
|
||||
"""A custom Gio.ListModel for working with playlists."""
|
||||
import datetime
|
||||
import sqlite3
|
||||
from gi.repository import GObject
|
||||
from .. import alarm
|
||||
from . import playlist
|
||||
from . import tracks
|
||||
|
||||
|
||||
class Playlist(playlist.Playlist):
|
||||
"""Our custom Playlist with an image filepath."""
|
||||
|
||||
playlistid = GObject.Property(type=int)
|
||||
image = GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
|
||||
def do_update(self, column: str) -> None:
|
||||
"""Update a playlist object."""
|
||||
match (self.name, column, self.get_property(column)):
|
||||
case ("Collection", "loop", "None"):
|
||||
self.loop = "Playlist"
|
||||
case ("Collection", "n-tracks", 0):
|
||||
self.table.have_collection_tracks = False
|
||||
case ("Collection", "n-tracks", _):
|
||||
self.table.have_collection_tracks = True
|
||||
case ("Previous Tracks", "loop", "Playlist") | \
|
||||
("Previous Tracks", "loop", "Track"):
|
||||
self.loop = "None"
|
||||
case ("Previous Tracks", "shuffle", True):
|
||||
self.shuffle = False
|
||||
case ("Previous Tracks", "sort-order", _):
|
||||
if self.sort_order != "laststarted DESC":
|
||||
self.sort_order = "laststarted DESC"
|
||||
case (_, _, _): super().do_update(column)
|
||||
|
||||
def rename(self, new_name: str) -> bool:
|
||||
"""Rename this playlist."""
|
||||
return self.table.rename(self, new_name)
|
||||
|
||||
@property
|
||||
def primary_key(self) -> int:
|
||||
"""Get the playlist primary key."""
|
||||
return self.playlistid
|
||||
|
||||
|
||||
class Table(playlist.Table):
|
||||
"""Our Playlist Table."""
|
||||
|
||||
collection = GObject.Property(type=Playlist)
|
||||
favorites = GObject.Property(type=Playlist)
|
||||
most_played = GObject.Property(type=Playlist)
|
||||
new_tracks = GObject.Property(type=Playlist)
|
||||
previous = GObject.Property(type=Playlist)
|
||||
queued = GObject.Property(type=Playlist)
|
||||
unplayed = GObject.Property(type=Playlist)
|
||||
|
||||
have_collection_tracks = GObject.Property(type=bool, default=False)
|
||||
|
||||
def __init__(self, sql: GObject.TYPE_PYOBJECT, **kwargs):
|
||||
"""Initialize the Playlists Table."""
|
||||
super().__init__(sql=sql, system_tracks=False, **kwargs)
|
||||
alarm.set_alarm(datetime.time(hour=0, minute=0, second=5),
|
||||
self.__at_midnight)
|
||||
|
||||
def __at_midnight(self) -> None:
|
||||
self.new_tracks.reload_tracks()
|
||||
|
||||
def __move_user_trackid(self, playlist: Playlist, trackid: int,
|
||||
*, offset: int) -> bool:
|
||||
order = self.get_track_order(playlist)
|
||||
tracks = sorted(playlist.tracks.trackids, key=order.get)
|
||||
start = tracks.index(trackid)
|
||||
|
||||
new = start + offset
|
||||
if not (0 <= new < len(tracks)):
|
||||
return False
|
||||
|
||||
tracks[start] = tracks[new]
|
||||
tracks[new] = trackid
|
||||
|
||||
# Note: We write out all trackids so we don't have to update during
|
||||
# do_add_track() and do_remove_track()
|
||||
args = [(i, playlist.propertyid, t) for (i, t) in enumerate(tracks)]
|
||||
self.sql.executemany("""UPDATE user_tracks SET position=?
|
||||
WHERE propertyid=? AND trackid=?""", *args)
|
||||
return True
|
||||
|
||||
def do_construct(self, **kwargs) -> Playlist:
|
||||
"""Construct a new playlist."""
|
||||
match (plist := Playlist(**kwargs)).name:
|
||||
case "Collection": self.collection = plist
|
||||
case "Favorite Tracks":
|
||||
self.favorites = plist
|
||||
self.favorites.user_tracks = True
|
||||
case "Most Played Tracks": self.most_played = plist
|
||||
case "New Tracks": self.new_tracks = plist
|
||||
case "Previous Tracks":
|
||||
self.previous = plist
|
||||
self.sql("DELETE FROM system_tracks WHERE propertyid=?",
|
||||
self.previous.propertyid)
|
||||
case "Queued Tracks":
|
||||
self.queued = plist
|
||||
self.queued.user_tracks = True
|
||||
self.queued.tracks_movable = True
|
||||
case "Unplayed Tracks": self.unplayed = plist
|
||||
case _:
|
||||
plist.user_tracks = True
|
||||
plist.tracks_movable = True
|
||||
return plist
|
||||
|
||||
def do_add_track(self, playlist: Playlist, track: tracks.Track) -> bool:
|
||||
"""Add a Track to the requested Playlist."""
|
||||
match playlist:
|
||||
case self.collection: return track.get_library().enabled
|
||||
case self.most_played: view = "most_played_view"
|
||||
case self.new_tracks: view = "new_tracks_view"
|
||||
case self.favorites:
|
||||
track.update_properties(favorite=True)
|
||||
return True
|
||||
case self.previous:
|
||||
self.add_system_track(playlist, track)
|
||||
return True
|
||||
case self.queued:
|
||||
self.sql.set_active_playlist(playlist)
|
||||
return self.add_user_track(playlist, track)
|
||||
case self.unplayed: return track.playcount == 0
|
||||
case _: return self.add_user_track(playlist, track)
|
||||
|
||||
return self.sql(f"SELECT ? IN {view}", track.trackid).fetchone()[0]
|
||||
|
||||
def do_get_user_track_order(self, playlist: Playlist) -> dict[int, int]:
|
||||
"""Get the user-configured sort order for a playlist."""
|
||||
cur = self.sql("""SELECT trackid FROM user_tracks WHERE propertyid=?
|
||||
ORDER BY position NULLS LAST, rowid""",
|
||||
playlist.propertyid)
|
||||
return {row["trackid"]: i for (i, row) in enumerate(cur.fetchall())}
|
||||
|
||||
def do_move_track_down(self, playlist: Playlist,
|
||||
track: tracks.Track) -> bool:
|
||||
"""Move a track down in the user sort order."""
|
||||
return self.__move_user_trackid(playlist, track.trackid, offset=1)
|
||||
|
||||
def do_move_track_up(self, playlist: Playlist,
|
||||
track: tracks.Track) -> bool:
|
||||
"""Move a track up in the user sort order."""
|
||||
return self.__move_user_trackid(playlist, track.trackid, offset=-1)
|
||||
|
||||
def do_remove_track(self, playlist: Playlist, track: tracks.Track) -> bool:
|
||||
"""Remove a Track from the requested Playlist."""
|
||||
match playlist:
|
||||
case self.collection: return True
|
||||
case self.most_played: return True
|
||||
case self.new_tracks: return True
|
||||
case self.unplayed: return True
|
||||
case self.favorites:
|
||||
track.update_properties(favorite=False)
|
||||
return True
|
||||
case self.previous:
|
||||
return self.remove_system_track(playlist, track)
|
||||
case _: return self.remove_user_track(playlist, track)
|
||||
|
||||
def do_sql_delete(self, playlist: Playlist) -> sqlite3.Cursor:
|
||||
"""Delete a playlist."""
|
||||
return self.sql("DELETE FROM playlists WHERE playlistid=?",
|
||||
playlist.playlistid)
|
||||
|
||||
def do_sql_glob(self, glob: str) -> sqlite3.Cursor:
|
||||
"""Search for playlists matching the search text."""
|
||||
return self.sql("""SELECT playlistid FROM playlists
|
||||
WHERE CASEFOLD(name) GLOB ?""", glob)
|
||||
|
||||
def do_sql_insert(self, name: str, **kwargs) -> sqlite3.Cursor | None:
|
||||
"""Insert a new playlist into the database."""
|
||||
if (cur := self.sql("INSERT INTO playlists (name) VALUES (?)", name)):
|
||||
return self.sql("SELECT * FROM playlists_view WHERE playlistid=?",
|
||||
cur.lastrowid)
|
||||
|
||||
def do_sql_select_all(self) -> sqlite3.Cursor:
|
||||
"""Load playlists from the database."""
|
||||
return self.sql("SELECT * FROM playlists_view")
|
||||
|
||||
def do_sql_select_trackids(self, playlist: Playlist) -> sqlite3.Cursor:
|
||||
"""Load Tracks from the database."""
|
||||
match playlist:
|
||||
case self.collection: view = "collection_view"
|
||||
case self.favorites: view = "favorite_view"
|
||||
case self.most_played: view = "most_played_view"
|
||||
case self.new_tracks: view = "new_tracks_view"
|
||||
case self.unplayed: view = "unplayed_tracks_view"
|
||||
case self.previous: return self.get_sql_system_trackids(playlist)
|
||||
case _: return self.get_sql_user_trackids(playlist)
|
||||
|
||||
return self.sql(f"SELECT trackid FROM {view}")
|
||||
|
||||
def do_sql_select_one(self, name: str) -> sqlite3.Cursor:
|
||||
"""Look up a playlist by name."""
|
||||
return self.sql("SELECT playlistid FROM playlists WHERE name=?", name)
|
||||
|
||||
def do_sql_update(self, playlist: Playlist,
|
||||
column: str, newval) -> sqlite3.Cursor:
|
||||
"""Update a playlist."""
|
||||
return self.sql(f"UPDATE playlists SET {column}=? WHERE playlistid=?",
|
||||
newval, playlist.playlistid)
|
||||
|
||||
def add_user_track(self, playlist: Playlist, track: tracks.Track) -> bool:
|
||||
"""Add a Track to the User Tracks table."""
|
||||
cur = self.sql("""INSERT INTO user_tracks (propertyid, trackid)
|
||||
VALUES (?, ?)""", playlist.propertyid, track.trackid)
|
||||
return cur and cur.rowcount == 1
|
||||
|
||||
def get_sql_user_trackids(self, playlist: Playlist) -> sqlite3.Cursor:
|
||||
"""Load user Tracks from the database."""
|
||||
return self.sql("""SELECT trackid FROM user_tracks_view
|
||||
WHERE propertyid=?""", playlist.propertyid)
|
||||
|
||||
def create(self, name: str) -> Playlist:
|
||||
"""Create a new Playlist."""
|
||||
if len(name := name.strip()) > 0:
|
||||
return super().create(name)
|
||||
|
||||
def remove_user_track(self, playlist: Playlist,
|
||||
track: tracks.Track) -> bool:
|
||||
"""Remove a track from the User Tracks table."""
|
||||
return self.sql("""DELETE FROM user_tracks
|
||||
WHERE propertyid=? AND trackid=?""",
|
||||
playlist.propertyid, track.trackid).rowcount == 1
|
||||
|
||||
def rename(self, playlist: Playlist, new_name: str) -> bool:
|
||||
"""Rename a Playlist."""
|
||||
if len(new_name := new_name.strip()) > 0:
|
||||
if playlist.name != new_name:
|
||||
if self.update(playlist, "name", new_name):
|
||||
self.store.remove(playlist)
|
||||
playlist.name = new_name
|
||||
self.store.append(playlist)
|
||||
return True
|
||||
return False
|
|
@ -0,0 +1,112 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""Easy access to the settings table in our database."""
|
||||
import sqlite3
|
||||
from gi.repository import GObject
|
||||
from . import idle
|
||||
from . import table
|
||||
|
||||
|
||||
class Setting(table.Row):
|
||||
"""Base class for settings."""
|
||||
|
||||
key = GObject.Property(type=str)
|
||||
|
||||
@property
|
||||
def primary_key(self) -> str:
|
||||
"""Get the primary key for this setting."""
|
||||
return self.key
|
||||
|
||||
|
||||
class IntSetting(Setting):
|
||||
"""An integer setting."""
|
||||
|
||||
value = GObject.Property(type=int)
|
||||
|
||||
|
||||
class FloatSetting(Setting):
|
||||
"""A float setting."""
|
||||
|
||||
value = GObject.Property(type=float)
|
||||
|
||||
|
||||
class BoolSetting(Setting):
|
||||
"""A boolean setting."""
|
||||
|
||||
value = GObject.Property(type=bool, default=False)
|
||||
|
||||
|
||||
class StringSetting(Setting):
|
||||
"""A string setting."""
|
||||
|
||||
value = GObject.Property(type=str)
|
||||
|
||||
|
||||
class Table(table.Table):
|
||||
"""Creates and manages our settings properties."""
|
||||
|
||||
def __init__(self, sql: GObject.TYPE_PYOBJECT):
|
||||
"""Initialize the settings table."""
|
||||
super().__init__(sql, queue=idle.Queue(enabled=False))
|
||||
|
||||
def __getitem__(self, key: str) -> int | float | str | bool | None:
|
||||
"""Get the value for a specific settings key."""
|
||||
if (setting := self.lookup(key)) is not None:
|
||||
return setting.value
|
||||
|
||||
def do_construct(self, type: str, value: any, **kwargs) -> table.Row:
|
||||
"""Construct a new settings row."""
|
||||
match type:
|
||||
case "gint":
|
||||
return IntSetting(value=int(value), **kwargs)
|
||||
case "gdouble":
|
||||
return FloatSetting(value=float(value), **kwargs)
|
||||
case "gboolean":
|
||||
value = str(value) == "True"
|
||||
return BoolSetting(value=value, **kwargs)
|
||||
case "gchararray":
|
||||
return StringSetting(value=value, **kwargs)
|
||||
|
||||
def do_get_sort_key(self, setting: table.Row) -> list[str]:
|
||||
"""Get the sort key for a specific setting."""
|
||||
return setting.key.casefold().split(".")
|
||||
|
||||
def do_sql_delete(self, setting: table.Row) -> sqlite3.Cursor:
|
||||
"""Delete a setting."""
|
||||
return self.sql("DELETE FROM settings WHERE key=?", setting.key)
|
||||
|
||||
def do_sql_glob(self, glob: str) -> sqlite3.Cursor:
|
||||
"""Filter the settings table."""
|
||||
return self.sql("""SELECT key FROM settings
|
||||
WHERE CASEFOLD(key) GLOB ?""", glob)
|
||||
|
||||
def do_sql_insert(self, key: str, type: str, value) -> sqlite3.Cursor:
|
||||
"""Create a new settings row."""
|
||||
return self.sql("""INSERT INTO settings (key, type, value)
|
||||
VALUES (?, ?, ?) RETURNING *""",
|
||||
key, type, str(value))
|
||||
|
||||
def do_sql_select_all(self) -> sqlite3.Cursor:
|
||||
"""Load settings from the database."""
|
||||
return self.sql("SELECT * FROM settings ORDER BY CASEFOLD(key)")
|
||||
|
||||
def do_sql_select_one(self, key: str) -> int | None:
|
||||
"""Look up a setting by key."""
|
||||
return self.sql("SELECT key FROM settings WHERE key=?", key)
|
||||
|
||||
def do_sql_update(self, setting: table.Row, column: str,
|
||||
newval: any) -> sqlite3.Cursor:
|
||||
"""Update a Setting."""
|
||||
return self.sql(f"UPDATE settings SET {column}=? WHERE key=?",
|
||||
str(newval), setting.key)
|
||||
|
||||
def bind_setting(self, key: str, target: GObject.GObject,
|
||||
property: str) -> None:
|
||||
"""Bind a setting to a target property."""
|
||||
if (setting := self.lookup(key=key)) is None:
|
||||
param = target.find_property(property)
|
||||
setting = self.create(key=key, type=param.value_type.name,
|
||||
value=target.get_property(property))
|
||||
else:
|
||||
target.set_property(property, setting.value)
|
||||
setting.bind_property("value", target, property,
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
|
@ -0,0 +1,347 @@
|
|||
# Copyright 2022 (c) Anna Schumaker
|
||||
"""Base classes for database objects."""
|
||||
import bisect
|
||||
import sqlite3
|
||||
from gi.repository import GObject
|
||||
from gi.repository import Gio
|
||||
from gi.repository import Gtk
|
||||
from .idle import Queue
|
||||
from .. import store
|
||||
|
||||
|
||||
class Row(GObject.GObject):
|
||||
"""A single row in a database table."""
|
||||
|
||||
table = GObject.Property(type=Gio.ListModel)
|
||||
|
||||
def __init__(self, table: Gio.ListModel, **kwargs):
|
||||
"""Initialize a database Row."""
|
||||
super().__init__(table=table, **kwargs)
|
||||
self.connect("notify", self.__notify)
|
||||
|
||||
def __notify(self, row: GObject.GObject, param: GObject.ParamSpec) -> None:
|
||||
match param.name:
|
||||
case "table": pass
|
||||
case _: self.do_update(param.name)
|
||||
|
||||
def do_update(self, column: str) -> bool:
|
||||
"""Update a Row in the database."""
|
||||
return self.table.update(self, column, self.get_property(column))
|
||||
|
||||
def delete(self) -> bool:
|
||||
"""Delete this Row."""
|
||||
return self.table.delete(self)
|
||||
|
||||
@property
|
||||
def primary_key(self) -> None:
|
||||
"""Get the primary key for this row."""
|
||||
raise NotImplementedError
|
||||
|
||||
|
||||
class KeySet(Gtk.Filter):
|
||||
"""A Gtk.Filter that also acts as a Python Set."""
|
||||
|
||||
n_keys = GObject.Property(type=int)
|
||||
|
||||
def __init__(self, keys: set | None = None, **kwargs):
|
||||
"""Set up our KeySet."""
|
||||
super().__init__(**kwargs)
|
||||
self._keys = keys
|
||||
self.n_keys = len(keys) if keys is not None else -1
|
||||
|
||||
def __contains__(self, row: Row) -> bool:
|
||||
"""Check if a Row is in the KeySet."""
|
||||
return self._keys is None or row.primary_key in self._keys
|
||||
|
||||
def __sub__(self, rhs: Gtk.Filter) -> set[int]:
|
||||
"""Subtract two KeySets and return the result."""
|
||||
match (self._keys, rhs._keys):
|
||||
case (None, _): return None
|
||||
case (_, None): return self._keys
|
||||
case (_, _): return self._keys - rhs._keys
|
||||
|
||||
def __find_difference(self, new: set[any] | None) \
|
||||
-> tuple[set, set, Gtk.FilterChange | None]:
|
||||
if self._keys is None:
|
||||
if new is None:
|
||||
return (set(), set(), None)
|
||||
return (set(), new, Gtk.FilterChange.MORE_STRICT)
|
||||
elif new is None:
|
||||
return (self._keys, set(), Gtk.FilterChange.LESS_STRICT)
|
||||
|
||||
removed = self._keys - new
|
||||
added = new - self._keys
|
||||
match len(removed), len(added):
|
||||
case 0, 0: return (removed, added, None)
|
||||
case _, 0: return (removed, added, Gtk.FilterChange.MORE_STRICT)
|
||||
case 0, _: return (removed, added, Gtk.FilterChange.LESS_STRICT)
|
||||
case _, _: return (removed, added, Gtk.FilterChange.DIFFERENT)
|
||||
|
||||
def changed(self, how: Gtk.FilterChange) -> None:
|
||||
"""Notify that the KeySet has changed."""
|
||||
self.n_keys = len(self._keys) if self._keys is not None else -1
|
||||
super().changed(how)
|
||||
|
||||
def do_get_strictness(self) -> Gtk.FilterMatch:
|
||||
"""Get the strictness of the Gtk.Filter."""
|
||||
if self._keys is None:
|
||||
return Gtk.FilterMatch.ALL
|
||||
if len(self._keys) == 0:
|
||||
return Gtk.FilterMatch.NONE
|
||||
return Gtk.FilterMatch.SOME
|
||||
|
||||
def do_match(self, row: Row) -> bool:
|
||||
"""Check if the Row is in the KeySet."""
|
||||
return self._keys is None or row.primary_key in self._keys
|
||||
|
||||
def add_row(self, row: Row) -> None:
|
||||
"""Add a Row to the KeySet."""
|
||||
if row not in self:
|
||||
self._keys.add(row.primary_key)
|
||||
self.emit("key-added", row.primary_key)
|
||||
self.changed(Gtk.FilterChange.LESS_STRICT)
|
||||
|
||||
def remove_row(self, row: Row) -> None:
|
||||
"""Remove a Row from the KeySet."""
|
||||
if self._keys is not None and row in self:
|
||||
self._keys.discard(row.primary_key)
|
||||
self.emit("key-removed", row.primary_key)
|
||||
self.changed(Gtk.FilterChange.MORE_STRICT)
|
||||
|
||||
@property
|
||||
def keys(self) -> set[any]:
|
||||
"""Return the set of matching primary keys."""
|
||||
return self._keys
|
||||
|
||||
@keys.setter
|
||||
def keys(self, keys: set[any] | None) -> None:
|
||||
"""Set the matching primary keys."""
|
||||
(removed, added, change) = self.__find_difference(keys)
|
||||
if change is not None:
|
||||
self._keys = keys
|
||||
self.emit("keys-changed", removed, added)
|
||||
self.changed(change)
|
||||
|
||||
@GObject.Signal(arg_types=(int,))
|
||||
def key_added(self, key: int) -> None:
|
||||
"""Signal that a Row has been added to the KeySet."""
|
||||
|
||||
@GObject.Signal(arg_types=(int,))
|
||||
def key_removed(self, key: int) -> None:
|
||||
"""Signal that a Row has been removed from the KeySet."""
|
||||
|
||||
@GObject.Signal(arg_types=(GObject.TYPE_PYOBJECT, GObject.TYPE_PYOBJECT))
|
||||
def keys_changed(self, removed: set | None, added: set | None) -> None:
|
||||
"""Signal that the KeySet has been directly modified."""
|
||||
|
||||
|
||||
class Table(Gtk.FilterListModel):
|
||||
"""An object that represents a database Table."""
|
||||
|
||||
sql = GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
queue = GObject.Property(type=Queue)
|
||||
store = GObject.Property(type=Gio.ListModel)
|
||||
rows = GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
|
||||
loaded = GObject.Property(type=bool, default=False)
|
||||
|
||||
def __init__(self, sql: GObject.TYPE_PYOBJECT,
|
||||
filter: KeySet | None = None,
|
||||
queue: Queue | None = None, **kwargs):
|
||||
"""Set up our Table object."""
|
||||
super().__init__(sql=sql, rows=dict(),
|
||||
store=store.SortedList(self.get_sort_key),
|
||||
filter=(filter if filter else KeySet()),
|
||||
queue=(queue if queue else Queue()), **kwargs)
|
||||
self.set_model(self.store)
|
||||
|
||||
def __clear_rows(self) -> None:
|
||||
self.rows.clear()
|
||||
self.store.clear()
|
||||
self.loaded = False
|
||||
|
||||
def __contains__(self, row: Row) -> bool:
|
||||
"""Check if the row is in the _rowid_map for this Table."""
|
||||
return self.index(row) is not None
|
||||
|
||||
def do_construct(self, *args, **kwargs) -> Row:
|
||||
"""Construct a new Row instance."""
|
||||
raise NotImplementedError
|
||||
|
||||
def do_get_sort_key(self, row: Row) -> any:
|
||||
"""Get a sort key for the requested row."""
|
||||
return None
|
||||
|
||||
def do_sql_delete(self, row: Row) -> bool:
|
||||
"""Delete a Row."""
|
||||
raise NotImplementedError
|
||||
|
||||
def do_sql_glob(self, glob: str) -> sqlite3.Cursor:
|
||||
"""Select matching rowids using GLOB."""
|
||||
raise NotImplementedError
|
||||
|
||||
def do_sql_insert(self, *args, **kwargs) -> sqlite3.Cursor:
|
||||
"""Create a new Row."""
|
||||
raise NotImplementedError
|
||||
|
||||
def do_sql_select_all(self) -> sqlite3.Cursor:
|
||||
"""Return all rows from the table."""
|
||||
raise NotImplementedError
|
||||
|
||||
def do_sql_select_one(self, *args, **kwargs) -> sqlite3.Cursor:
|
||||
"""Look up a single row."""
|
||||
raise NotImplementedError
|
||||
|
||||
def do_sql_update(self, row: Row, column: str, newval) -> sqlite3.Cursor:
|
||||
"""Update a row."""
|
||||
raise NotImplementedError
|
||||
|
||||
def clear(self) -> None:
|
||||
"""Clear the table."""
|
||||
self.stop()
|
||||
self.__clear_rows()
|
||||
|
||||
def construct(self, *args, **kwargs) -> Row:
|
||||
"""Construct a new Row instance."""
|
||||
return self.do_construct(table=self, *args, **kwargs)
|
||||
|
||||
def create(self, *args, **kwargs) -> Row | None:
|
||||
"""Create a new Row in the Table."""
|
||||
if cur := self.do_sql_insert(*args, **kwargs):
|
||||
return self.insert(self.construct(**cur.fetchone()))
|
||||
|
||||
def delete(self, row: Row) -> bool:
|
||||
"""Delete a Row from the Table."""
|
||||
if row in self and self.do_sql_delete(row).rowcount == 1:
|
||||
self.sql.commit()
|
||||
self.store.remove(row)
|
||||
del self.rows[row.primary_key]
|
||||
return True
|
||||
return False
|
||||
|
||||
def _filter_idle(self, glob: str) -> bool:
|
||||
rows = self.do_sql_glob(glob).fetchall()
|
||||
self.get_filter().keys = {row[0] for row in rows}
|
||||
return True
|
||||
|
||||
def filter(self, glob: str | None, *, now: bool = False) -> None:
|
||||
"""Filter the displayed Rows."""
|
||||
if glob is not None:
|
||||
self.queue.cancel_task(self._filter_idle)
|
||||
self.queue.push(self._filter_idle, glob, now=now, first=True)
|
||||
else:
|
||||
self.get_filter().keys = None
|
||||
|
||||
def get_sort_key(self, row: Row) -> tuple:
|
||||
"""Get a sort key for the requested row."""
|
||||
res = self.do_get_sort_key(row)
|
||||
return res if res is not None else row.primary_key
|
||||
|
||||
def index(self, row: Row) -> int | None:
|
||||
"""Find the index of a specific Row."""
|
||||
if row.table is self:
|
||||
return self.store.index(row)
|
||||
|
||||
def insert(self, row: Row) -> Row | None:
|
||||
"""Insert a Row in sorted position."""
|
||||
if row and row not in self:
|
||||
self.store.append(row)
|
||||
return self.rows.setdefault(row.primary_key, row)
|
||||
|
||||
def _load_idle(self) -> bool:
|
||||
self.__clear_rows()
|
||||
cur = self.do_sql_select_all()
|
||||
rows = [self.construct(**row) for row in cur.fetchall()]
|
||||
self.store.extend(rows)
|
||||
self.rows = {row.primary_key: row for row in rows}
|
||||
self.sql.emit("table-loaded", self)
|
||||
return True
|
||||
|
||||
def load(self, *, now: bool = False) -> None:
|
||||
"""Load the Table from the database."""
|
||||
self.queue.push(self._load_idle, now=now)
|
||||
|
||||
def lookup(self, *args, **kwargs) -> Row | None:
|
||||
"""Look up a Row in the database."""
|
||||
row = self.do_sql_select_one(*args, **kwargs).fetchone()
|
||||
return self.rows.get(row[0]) if row else None
|
||||
|
||||
def stop(self) -> None:
|
||||
"""Stop any background work."""
|
||||
self.queue.cancel()
|
||||
|
||||
def update(self, row: Row, column: str, newval) -> bool:
|
||||
"""Update a Row."""
|
||||
return self.do_sql_update(row, column, newval) is not None
|
||||
|
||||
|
||||
class TableSubset(GObject.GObject, Gio.ListModel):
|
||||
"""A list model containing a subset of the rows in the source Table."""
|
||||
|
||||
keyset = GObject.Property(type=KeySet)
|
||||
table = GObject.Property(type=Table)
|
||||
n_rows = GObject.Property(type=int)
|
||||
|
||||
def __init__(self, table: Table, *, keys: set[any] | None = None):
|
||||
"""Initialize a KeySetModel."""
|
||||
super().__init__(keyset=KeySet(set() if keys is None else keys),
|
||||
table=table)
|
||||
self._items = []
|
||||
|
||||
self.keyset.connect("key-added", self.__on_key_added)
|
||||
self.keyset.connect("key-removed", self.__on_key_removed)
|
||||
self.table.connect("notify::loaded", self.__notify_table_loaded)
|
||||
|
||||
def __contains__(self, row: Row) -> bool:
|
||||
"""Check if the Row is in the internal KeySet."""
|
||||
return row in self.keyset
|
||||
|
||||
def __bisect(self, key: any) -> int | None:
|
||||
if self.table.loaded:
|
||||
sort_key = self.table.get_sort_key(self.table.rows[key])
|
||||
return bisect.bisect_left(self._items, sort_key,
|
||||
key=self.table.get_sort_key)
|
||||
return None
|
||||
|
||||
def __items_changed(self, position: int, removed: int, added: int) -> None:
|
||||
self.n_rows = len(self._items)
|
||||
self.items_changed(position, removed, added)
|
||||
|
||||
def __notify_table_loaded(self, table: Table, param) -> None:
|
||||
if table.loaded and self.keyset.n_keys > 0:
|
||||
self._items = sorted([table.rows[k] for k in self.keyset.keys],
|
||||
key=self.table.get_sort_key)
|
||||
self.__items_changed(0, 0, self.keyset.n_keys)
|
||||
elif not table.loaded and self.n_rows > 0:
|
||||
self._items = []
|
||||
self.__items_changed(0, self.n_rows, 0)
|
||||
|
||||
def __on_key_added(self, keyset: KeySet, key: any) -> None:
|
||||
if (pos := self.__bisect(key)) is not None:
|
||||
self._items.insert(pos, self.table.rows[key])
|
||||
self.__items_changed(pos, 0, 1)
|
||||
|
||||
def __on_key_removed(self, keyset: KeySet, key: any) -> None:
|
||||
if (pos := self.__bisect(key)) is not None:
|
||||
del self._items[pos]
|
||||
self.__items_changed(pos, 1, 0)
|
||||
|
||||
def do_get_item_type(self) -> GObject.GType:
|
||||
"""Get the Gio.ListModel item type."""
|
||||
return Row.__gtype__
|
||||
|
||||
def do_get_n_items(self) -> int:
|
||||
"""Get the number of Rows in the TableSubset."""
|
||||
return self.n_rows
|
||||
|
||||
def do_get_item(self, n: int) -> int:
|
||||
"""Get the nth item in the TableSubset."""
|
||||
return self._items[n] if n < len(self._items) else None
|
||||
|
||||
def add_row(self, row: Row) -> None:
|
||||
"""Add a row to the TableSubset."""
|
||||
self.keyset.add_row(row)
|
||||
|
||||
def remove_row(self, row: Row) -> None:
|
||||
"""Remove a row from the TableSubset."""
|
||||
self.keyset.remove_row(row)
|
|
@ -0,0 +1,242 @@
|
|||
# Copyright 2022 (c) Anna Schumaker
|
||||
"""A wrapper around Mutagen to help us read tags."""
|
||||
import emmental.audio.tagger
|
||||
import musicbrainzngs
|
||||
import pathlib
|
||||
from gi.repository import GObject
|
||||
from .. import audio
|
||||
from .. import thread
|
||||
from . import albums
|
||||
from . import artists
|
||||
from . import connection
|
||||
from . import decades
|
||||
from . import media
|
||||
from . import genres
|
||||
from . import playlist
|
||||
from . import tracks
|
||||
from . import years
|
||||
|
||||
|
||||
class Tags:
|
||||
"""Translate the audio.tagger._Tags object into Playlists."""
|
||||
|
||||
def __init__(self, db: GObject.TYPE_PYOBJECT,
|
||||
raw_tags: audio.tagger._Tags,
|
||||
library: playlist.Playlist):
|
||||
"""Initialize the Tags object."""
|
||||
self.db = db
|
||||
|
||||
with self.db:
|
||||
self.album = self.get_album(raw_tags.album)
|
||||
self.album_artists = [self.get_artist(artist)
|
||||
for artist in raw_tags.album.artists]
|
||||
self.artists = [self.get_artist(artist)
|
||||
for artist in raw_tags.artists]
|
||||
self.decade = self.get_decade(raw_tags.year)
|
||||
self.genres = list(filter(None, [self.get_genre(genre)
|
||||
for genre in raw_tags.genres]))
|
||||
self.medium = self.get_medium(raw_tags.medium)
|
||||
self.year = self.get_year(raw_tags.year)
|
||||
|
||||
self.track = self.get_track(library, raw_tags.file, raw_tags.track)
|
||||
|
||||
self.__update_album_artists()
|
||||
|
||||
def __update_album_artists(self) -> None:
|
||||
if self.album is not None:
|
||||
old = set(self.album.get_artists())
|
||||
new = set(self.album_artists)
|
||||
|
||||
for artist in old - new:
|
||||
artist.remove_album(self.album)
|
||||
for artist in new - old:
|
||||
artist.add_album(self.album)
|
||||
|
||||
def __update_track(self, track: tracks.Track,
|
||||
raw_track: audio.tagger._Track) -> None:
|
||||
orig_year = track.get_year()
|
||||
orig_decade = orig_year.parent
|
||||
orig_genres = set(track.get_genres())
|
||||
orig_medium = track.get_medium()
|
||||
orig_album = orig_medium.get_album()
|
||||
orig_artists = set(track.get_artists())
|
||||
|
||||
track.update_properties(mediumid=self.medium.mediumid,
|
||||
year=self.year.year,
|
||||
title=raw_track.title,
|
||||
number=raw_track.number,
|
||||
length=raw_track.length,
|
||||
artist=raw_track.artist,
|
||||
mbid=raw_track.mbid,
|
||||
mtime=raw_track.mtime)
|
||||
|
||||
self.__update_track_playlist_set(track, orig_artists,
|
||||
set(self.artists))
|
||||
self.__update_track_playlist_set(track, orig_genres, set(self.genres))
|
||||
|
||||
self.__update_track_playlist(track, orig_album, self.album)
|
||||
self.__update_track_playlist(track, orig_medium, self.medium)
|
||||
self.__update_track_playlist(track, orig_decade, self.decade)
|
||||
self.__update_track_playlist(track, orig_year, self.year)
|
||||
|
||||
def __update_track_playlist(self, track: tracks.Track,
|
||||
orig: playlist.Playlist,
|
||||
new: playlist.Playlist):
|
||||
if orig != new:
|
||||
orig.remove_track(track, idle=True)
|
||||
new.add_track(track, idle=True)
|
||||
|
||||
def __update_track_playlist_set(self, track: tracks.Track,
|
||||
orig: set[playlist.Playlist],
|
||||
new: set[playlist.Playlist]):
|
||||
for plist in orig - new:
|
||||
plist.remove_track(track, idle=True)
|
||||
for plist in new - orig:
|
||||
plist.add_track(track, idle=True)
|
||||
|
||||
def get_album(self, raw_album: audio.tagger._Album) -> albums.Album | None:
|
||||
"""Convert the raw album into an Album object."""
|
||||
if raw_album.name == "":
|
||||
return None
|
||||
|
||||
cover = raw_album.cover if raw_album.cover.is_file() else None
|
||||
album = self.db.albums.lookup(raw_album.name, raw_album.artist,
|
||||
raw_album.release, mbid=raw_album.mbid)
|
||||
if album is not None:
|
||||
if album.cover != cover:
|
||||
album.cover = cover
|
||||
return album
|
||||
return self.db.albums.create(raw_album.name, raw_album.artist,
|
||||
raw_album.release, mbid=raw_album.mbid,
|
||||
cover=cover)
|
||||
|
||||
def get_artist(self, raw_artist: audio.tagger._Artist) \
|
||||
-> artists.Artist | None:
|
||||
"""Convert the raw artist into an Artist object."""
|
||||
artist = self.db.artists.lookup(raw_artist.name, mbid=raw_artist.mbid)
|
||||
if artist is not None:
|
||||
return artist
|
||||
return self.db.artists.create(raw_artist.name, mbid=raw_artist.mbid)
|
||||
|
||||
def get_decade(self, raw_year: int | None) -> decades.Decade | None:
|
||||
"""Convert the raw year into a Decade object."""
|
||||
if raw_year:
|
||||
decade = self.db.decades.lookup(raw_year)
|
||||
return decade if decade else self.db.decades.create(raw_year)
|
||||
|
||||
def get_genre(self, raw_genre: str) -> genres.Genre:
|
||||
"""Convert the raw genre names into Genre objects."""
|
||||
genre = self.db.genres.lookup(raw_genre)
|
||||
return genre if genre else self.db.genres.create(raw_genre)
|
||||
|
||||
def get_medium(self, raw_medium: audio.tagger._Medium) \
|
||||
-> media.Medium | None:
|
||||
"""Convert the raw medium into a Medium object."""
|
||||
if self.album is None:
|
||||
return None
|
||||
|
||||
medium = self.db.media.lookup(self.album, number=raw_medium.number,
|
||||
type=raw_medium.type)
|
||||
if medium is not None:
|
||||
medium.rename(raw_medium.name)
|
||||
return medium
|
||||
return self.db.media.create(self.album, raw_medium.name,
|
||||
number=raw_medium.number,
|
||||
type=raw_medium.type)
|
||||
|
||||
def get_track(self, library: playlist.Playlist, filepath: pathlib.Path,
|
||||
raw_track: audio.tagger._Track) -> tracks.Track | None:
|
||||
"""Convert the raw track into a Track object."""
|
||||
if self.medium is None or self.year is None:
|
||||
return None
|
||||
|
||||
track = self.db.tracks.lookup(library, path=filepath)
|
||||
if track is not None:
|
||||
self.__update_track(track, raw_track)
|
||||
return track
|
||||
|
||||
track = self.db.tracks.create(library, filepath, self.medium,
|
||||
self.year, title=raw_track.title,
|
||||
number=raw_track.number,
|
||||
length=raw_track.length,
|
||||
artist=raw_track.artist,
|
||||
mbid=raw_track.mbid,
|
||||
mtime=raw_track.mtime)
|
||||
|
||||
for plist in [self.db.playlists.collection,
|
||||
self.db.playlists.new_tracks,
|
||||
self.db.playlists.unplayed,
|
||||
self.album, *self.artists, self.medium,
|
||||
*self.genres, self.decade, self.year, library]:
|
||||
plist.add_track(track, idle=True)
|
||||
return track
|
||||
|
||||
def get_year(self, raw_year: int | None) -> years.Year | None:
|
||||
"""Convert the raw year into a Year object."""
|
||||
if raw_year:
|
||||
year = self.db.years.lookup(raw_year)
|
||||
return year if year else self.db.years.create(raw_year)
|
||||
|
||||
|
||||
class Thread(thread.Thread):
|
||||
"""A thread for tagging files without blocking the UI."""
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize the Tagger Thread."""
|
||||
super().__init__()
|
||||
self._connection = None
|
||||
|
||||
def __get_connection(self) -> connection.Connection:
|
||||
if not self._connection:
|
||||
self._connection = connection.Connection()
|
||||
return self._connection
|
||||
|
||||
def __check_artist(self, artist: audio.tagger._Artist) -> None:
|
||||
if artist.name is None and len(artist.mbid) > 0:
|
||||
sql = self.__get_connection()
|
||||
cur = sql("SELECT name FROM artists WHERE mbid=?", artist.mbid)
|
||||
if row := cur.fetchone():
|
||||
artist.name = row["name"]
|
||||
else:
|
||||
mb_res = musicbrainzngs.get_artist_by_id(artist.mbid)
|
||||
artist.name = mb_res["artist"]["name"]
|
||||
|
||||
def do_get_result(self, result: thread.Data, db: GObject.TYPE_PYOBJECT,
|
||||
library: playlist.Playlist) -> tuple:
|
||||
"""Return the resulting Tags structure."""
|
||||
tags = None if result.tags is None else Tags(db, result.tags, library)
|
||||
return (result.path, tags)
|
||||
|
||||
def do_run_task(self, task: thread.Data) -> None:
|
||||
"""Tag a file."""
|
||||
tags = emmental.audio.tagger.tag_file(task.path, task.mtime)
|
||||
if tags is not None:
|
||||
for artist in tags.artists:
|
||||
self.__check_artist(artist)
|
||||
|
||||
self.set_result(path=task.path, tags=tags)
|
||||
|
||||
def do_stop(self) -> None:
|
||||
"""Close the connection before stopping."""
|
||||
if self._connection:
|
||||
self._connection.close()
|
||||
self._connection = None
|
||||
|
||||
def tag_file(self, path: pathlib.Path,
|
||||
*, mtime: float | None = None) -> None:
|
||||
"""Tag a file."""
|
||||
self.set_task(path=path, mtime=mtime)
|
||||
|
||||
|
||||
def untag_track(db: GObject.TYPE_PYOBJECT, track: tracks.Track) -> None:
|
||||
"""Untag a Track."""
|
||||
medium = track.get_medium()
|
||||
year = track.get_year()
|
||||
|
||||
playlists = [plist for plist in db.playlists.store]
|
||||
playlists.extend([medium, medium.get_album()])
|
||||
playlists.extend(track.get_artists())
|
||||
playlists.extend([year, year.parent, track.get_library()])
|
||||
|
||||
for plist in playlists:
|
||||
plist.remove_track(track)
|
|
@ -0,0 +1,374 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""A custom Gio.ListModel for working with tracks."""
|
||||
import datetime
|
||||
import pathlib
|
||||
import random
|
||||
import sqlite3
|
||||
from typing import Iterable
|
||||
from gi.repository import GObject
|
||||
from gi.repository import Gtk
|
||||
from . import table
|
||||
|
||||
|
||||
PLAYED_THRESHOLD = 2 / 3
|
||||
|
||||
|
||||
class Track(table.Row):
|
||||
"""Our custom Track object."""
|
||||
|
||||
trackid = GObject.Property(type=int)
|
||||
libraryid = GObject.Property(type=int)
|
||||
mediumid = GObject.Property(type=int)
|
||||
year = GObject.Property(type=int)
|
||||
|
||||
active = GObject.Property(type=bool, default=False)
|
||||
favorite = GObject.Property(type=bool, default=False)
|
||||
|
||||
path = GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
mbid = GObject.Property(type=str)
|
||||
title = GObject.Property(type=str)
|
||||
artist = GObject.Property(type=str)
|
||||
number = GObject.Property(type=int)
|
||||
length = GObject.Property(type=float)
|
||||
mtime = GObject.Property(type=float)
|
||||
playcount = GObject.Property(type=int)
|
||||
added = GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
|
||||
laststarted = GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
lastplayed = GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
restarted = GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
|
||||
def do_update(self, column: str) -> bool:
|
||||
"""Update a Track object."""
|
||||
match column:
|
||||
case "trackid" | "libraryid" | "active" | "path" | "playcount" | \
|
||||
"laststarted" | "lastplayed" | "restarted": pass
|
||||
case _: return super().do_update(column)
|
||||
return True
|
||||
|
||||
def get_artists(self) -> list[table.Row]:
|
||||
"""Get a list of Artists for this Track."""
|
||||
return self.table.get_artists(self)
|
||||
|
||||
def get_genres(self) -> list[table.Row]:
|
||||
"""Get a list of Genres for this Track."""
|
||||
return self.table.get_genres(self)
|
||||
|
||||
def get_library(self) -> table.Row | None:
|
||||
"""Get the Library associated with this Track."""
|
||||
return self.table.sql.libraries.rows.get(self.libraryid)
|
||||
|
||||
def get_medium(self) -> table.Row | None:
|
||||
"""Get the Medium associated with this Track."""
|
||||
return self.table.sql.media.rows.get(self.mediumid)
|
||||
|
||||
def get_year(self) -> table.Row | None:
|
||||
"""Get the Year associated with this Track."""
|
||||
return self.table.sql.years.rows.get(self.year)
|
||||
|
||||
def restart(self) -> None:
|
||||
"""Mark that a previously started track has been started again."""
|
||||
self.table.restart_track(self)
|
||||
|
||||
def start(self) -> None:
|
||||
"""Mark that this track has started playback."""
|
||||
self.table.start_track(self)
|
||||
|
||||
def stop(self, play_time: float) -> None:
|
||||
"""Mark that this track has stopped playback."""
|
||||
self.table.stop_track(self, play_time / self.length > PLAYED_THRESHOLD)
|
||||
|
||||
def update_properties(self, **kwargs) -> None:
|
||||
"""Update one or more of this Track's properties."""
|
||||
for (property, newval) in kwargs.items():
|
||||
if self.get_property(property) != newval:
|
||||
self.set_property(property, newval)
|
||||
|
||||
@property
|
||||
def primary_key(self) -> int:
|
||||
"""Get the primary key for this Track."""
|
||||
return self.trackid
|
||||
|
||||
|
||||
class Filter(table.KeySet):
|
||||
"""A customized Filter that never sets strictness to FilterMatch.All."""
|
||||
|
||||
def do_get_strictness(self) -> Gtk.FilterMatch:
|
||||
"""Get the strictness of the filter."""
|
||||
if self.n_keys == 0:
|
||||
return Gtk.FilterMatch.NONE
|
||||
return Gtk.FilterMatch.SOME
|
||||
|
||||
|
||||
class Table(table.Table):
|
||||
"""A ListStore tailored for storing Track objects."""
|
||||
|
||||
have_current_track = GObject.Property(type=bool, default=False)
|
||||
current_track = GObject.Property(type=Track)
|
||||
current_favorite = GObject.Property(type=bool, default=False)
|
||||
|
||||
def __init__(self, sql: GObject.TYPE_PYOBJECT):
|
||||
"""Initialize a Track Table."""
|
||||
super().__init__(sql, filter=Filter())
|
||||
self.set_model(None)
|
||||
self.connect("notify::current-track", self.__notify_current_track)
|
||||
self.connect("notify::current-favorite",
|
||||
self.__notify_current_favorite)
|
||||
|
||||
def __notify_current_track(self, table: table.Table, param) -> None:
|
||||
if self.current_track is not None:
|
||||
self.have_current_track = True
|
||||
self.current_favorite = self.current_track.favorite
|
||||
self.sql.playlists.previous.add_track(self.current_track)
|
||||
else:
|
||||
self.have_current_track = False
|
||||
self.current_favorite = False
|
||||
|
||||
def __notify_current_favorite(self, table: table.Table, param) -> None:
|
||||
if self.current_track is not None:
|
||||
self.current_track.update_properties(
|
||||
favorite=self.current_favorite)
|
||||
elif self.current_favorite is True:
|
||||
self.current_favorite = False
|
||||
|
||||
def do_construct(self, **kwargs) -> Track:
|
||||
"""Construct a new Track instance."""
|
||||
if (track := Track(**kwargs)).active:
|
||||
self.current_track = track
|
||||
return track
|
||||
|
||||
def do_sql_delete(self, track: Track) -> sqlite3.Cursor:
|
||||
"""Delete a Track."""
|
||||
return self.sql("DELETE FROM tracks WHERE trackid=?", track.trackid)
|
||||
|
||||
def do_sql_glob(self, glob: str) -> sqlite3.Cursor:
|
||||
"""Filter the Track table."""
|
||||
return self.sql("""SELECT trackid FROM track_info_view WHERE
|
||||
CASEFOLD(title) GLOB :glob
|
||||
OR CASEFOLD(artist) GLOB :glob
|
||||
OR CASEFOLD(album) GLOB :glob
|
||||
OR CASEFOLD(albumartist) GLOB :glob
|
||||
OR CASEFOLD(medium) GLOB :glob
|
||||
OR release GLOB :glob""", glob=glob)
|
||||
|
||||
def do_sql_insert(self, library: table.Row, path: pathlib.Path,
|
||||
medium: table.Row, year: table.Row, *, title: str = "",
|
||||
number: int = 0, length: float = 0.0, artist: str = "",
|
||||
mbid: str = "", mtime: float = 0.0) -> sqlite3.Cursor:
|
||||
"""Insert a new Track into the database."""
|
||||
if cur := self.sql("""INSERT INTO tracks
|
||||
(libraryid, mediumid, path, year, title,
|
||||
number, length, artist, mbid, mtime)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
RETURNING *""",
|
||||
library.libraryid, medium.mediumid, path, year.year,
|
||||
title, number, length, artist, mbid, mtime):
|
||||
return self.sql("SELECT * FROM tracks WHERE trackid=?",
|
||||
cur.lastrowid)
|
||||
|
||||
def do_sql_select_all(self) -> sqlite3.Cursor:
|
||||
"""Load Tracks from the database."""
|
||||
return self.sql("SELECT * FROM tracks")
|
||||
|
||||
def do_sql_select_one(self, library: table.Row = None,
|
||||
*, path: pathlib.Path = None,
|
||||
mbid: str = None) -> sqlite3.Cursor:
|
||||
"""Look up a Track in the database."""
|
||||
if path is None and mbid is None:
|
||||
raise KeyError("Either 'path' or 'mbid' are required")
|
||||
|
||||
args = [("libraryid=?", library.libraryid if library else None),
|
||||
("path=?", path), ("mbid=?", mbid)]
|
||||
|
||||
(where, args) = tuple(zip(*[arg for arg in args if None not in arg]))
|
||||
sql_where = " AND ".join(where)
|
||||
return self.sql(f"SELECT trackid FROM tracks WHERE {sql_where}", *args)
|
||||
|
||||
def do_sql_update(self, track: Track, column: str,
|
||||
newval: any) -> sqlite3.Cursor:
|
||||
"""Update a Track."""
|
||||
match (column, newval):
|
||||
case ("favorite", True):
|
||||
self.sql.playlists.favorites.add_track(track)
|
||||
if track == self.current_track:
|
||||
self.current_favorite = True
|
||||
case ("favorite", False):
|
||||
self.sql.playlists.favorites.remove_track(track)
|
||||
if track == self.current_track:
|
||||
self.current_favorite = False
|
||||
|
||||
return self.sql(f"UPDATE tracks SET {column}=? WHERE trackid=?",
|
||||
newval, track.trackid)
|
||||
|
||||
def delete_listens(self, listenids: list[int]) -> None:
|
||||
"""Delete the listens indicated by the provided listenids."""
|
||||
self.sql.executemany("""DELETE FROM listenbrainz_queue
|
||||
WHERE listenid=?""",
|
||||
*[(id,) for id in listenids])
|
||||
|
||||
def get_artists(self, track: Track) -> list[table.Row]:
|
||||
"""Get the set of Artists for a specific Track."""
|
||||
rows = self.sql("""SELECT artistid FROM artist_tracks_view
|
||||
WHERE trackid=?""", track.trackid).fetchall()
|
||||
return [self.sql.artists.rows.get(row["artistid"]) for row in rows]
|
||||
|
||||
def get_genres(self, track: Track) -> list[int]:
|
||||
"""Get the list of Genres for a specific Track."""
|
||||
rows = self.sql("""SELECT genreid FROM genre_tracks_view
|
||||
WHERE trackid=?""", track.trackid).fetchall()
|
||||
return [self.sql.genres.rows.get(row["genreid"]) for row in rows]
|
||||
|
||||
def get_n_listens(self, n: int) -> list[tuple]:
|
||||
"""Get the n most recent listens from the listenbrainz queue."""
|
||||
cur = self.sql("""SELECT listenid, trackid, timestamp
|
||||
FROM listenbrainz_queue ORDER BY timestamp DESC
|
||||
LIMIT ?""", n)
|
||||
return [(row["listenid"], self.rows[row["trackid"]], row["timestamp"])
|
||||
for row in cur.fetchall()]
|
||||
|
||||
def map_sort_order(self, ordering: str) -> dict[int, int]:
|
||||
"""Get a lookup table for Track sort keys."""
|
||||
ordering = ordering if len(ordering) > 0 else "trackid"
|
||||
cur = self.sql(f"""SELECT trackid FROM track_info_view
|
||||
ORDER BY {ordering}""")
|
||||
return {row["trackid"]: i for (i, row) in enumerate(cur.fetchall())}
|
||||
|
||||
def mark_path_active(self, path: pathlib.Path) -> None:
|
||||
"""Mark a specific track as active in the database.."""
|
||||
if self.sql("UPDATE tracks SET active=TRUE WHERE path=?",
|
||||
path).rowcount == 0:
|
||||
self.sql("UPDATE tracks SET active=FALSE WHERE active=TRUE")
|
||||
|
||||
def restart_track(self, track: Track) -> None:
|
||||
"""Mark that a Track has been restarted."""
|
||||
track.active = True
|
||||
track.restarted = datetime.datetime.utcnow()
|
||||
self.current_track = track
|
||||
|
||||
def start_track(self, track: Track) -> None:
|
||||
"""Mark that a Track has been started."""
|
||||
self.sql.playlists.previous.remove_track(track)
|
||||
|
||||
cur = self.sql("""UPDATE tracks SET active=TRUE, laststarted=?
|
||||
WHERE trackid=? RETURNING laststarted""",
|
||||
datetime.datetime.utcnow(), track.trackid)
|
||||
track.active = True
|
||||
track.laststarted = cur.fetchone()["laststarted"]
|
||||
self.current_track = track
|
||||
self.sql.commit()
|
||||
|
||||
def stop_track(self, track: Track, played: bool) -> None:
|
||||
"""Mark that a Track has been stopped."""
|
||||
args = [("active=?", False)]
|
||||
|
||||
if played:
|
||||
if track.restarted is not None:
|
||||
track.laststarted = track.restarted
|
||||
args.append(("laststarted=?", track.restarted))
|
||||
args.append(("lastplayed=?", track.laststarted))
|
||||
args.append(("playcount=?", track.playcount + 1))
|
||||
|
||||
(fields, vals) = tuple(zip(*args))
|
||||
update = ", ".join(fields)
|
||||
row = self.sql(f"""UPDATE tracks SET {update} WHERE trackid=?
|
||||
RETURNING lastplayed, playcount""",
|
||||
*vals, track.trackid).fetchone()
|
||||
|
||||
track.active = False
|
||||
track.playcount = row["playcount"]
|
||||
track.lastplayed = row["lastplayed"]
|
||||
track.restarted = None
|
||||
self.current_track = None
|
||||
|
||||
if played:
|
||||
self.sql.playlists.most_played.reload_tracks(idle=True)
|
||||
self.sql.playlists.queued.remove_track(track)
|
||||
self.sql.playlists.unplayed.remove_track(track)
|
||||
self.emit("track-played", track)
|
||||
|
||||
self.sql.commit()
|
||||
|
||||
@GObject.Signal(arg_types=(Track,))
|
||||
def track_played(self, track: Track) -> None:
|
||||
"""Signal that a Track was played."""
|
||||
if track is not None:
|
||||
self.sql("""INSERT INTO listenbrainz_queue (trackid, timestamp)
|
||||
VALUES (?, ?)""", track.trackid, track.lastplayed)
|
||||
|
||||
|
||||
class TrackidSet(GObject.GObject):
|
||||
"""Manage a set of Track IDs."""
|
||||
|
||||
n_trackids = GObject.Property(type=int)
|
||||
|
||||
def __init__(self, trackids: Iterable[int] = []):
|
||||
"""Initialize a TrackidSet."""
|
||||
super().__init__()
|
||||
self.__trackids = set(trackids)
|
||||
self.n_trackids = len(self.__trackids)
|
||||
|
||||
def __contains__(self, track: Track) -> bool:
|
||||
"""Check if a Track is in the set."""
|
||||
return track.trackid in self.__trackids
|
||||
|
||||
def __len__(self) -> int:
|
||||
"""Find the number of Tracks in the set."""
|
||||
return len(self.__trackids)
|
||||
|
||||
def __sub__(self, rhs):
|
||||
"""Subtract two TrackidSets."""
|
||||
return TrackidSet(self.__trackids - rhs.trackids)
|
||||
|
||||
def add_track(self, track: Track) -> None:
|
||||
"""Add a Track to the set."""
|
||||
if track.trackid not in self.__trackids:
|
||||
self.__trackids.add(track.trackid)
|
||||
self.n_trackids = len(self)
|
||||
self.emit("trackid-added", track.trackid)
|
||||
|
||||
def random_trackid(self) -> int | None:
|
||||
"""Get a random trackid from the set."""
|
||||
if len(self.__trackids) > 0:
|
||||
return random.choice(list(self.__trackids))
|
||||
|
||||
def remove_track(self, track: Track) -> None:
|
||||
"""Remove a Track from the set."""
|
||||
if track.trackid in self.__trackids:
|
||||
self.__trackids.discard(track.trackid)
|
||||
self.n_trackids = len(self)
|
||||
self.emit("trackid-removed", track.trackid)
|
||||
|
||||
@property
|
||||
def trackids(self) -> set:
|
||||
"""Get the set of trackids."""
|
||||
return self.__trackids
|
||||
|
||||
@trackids.setter
|
||||
def trackids(self, trackids: Iterable[int]) -> None:
|
||||
"""Add several trackids to the set at one time."""
|
||||
new_trackids = set(trackids)
|
||||
if self.__trackids.isdisjoint(new_trackids):
|
||||
self.__trackids = new_trackids
|
||||
self.n_trackids = len(self)
|
||||
self.emit("trackids-reset")
|
||||
else:
|
||||
removed = self.__trackids - new_trackids
|
||||
added = new_trackids - self.__trackids
|
||||
self.__trackids = new_trackids
|
||||
self.n_trackids = len(self)
|
||||
for id in removed:
|
||||
self.emit("trackid-removed", id)
|
||||
for id in added:
|
||||
self.emit("trackid-added", id)
|
||||
|
||||
@GObject.Signal(arg_types=(int,))
|
||||
def trackid_added(self, trackid: int) -> None:
|
||||
"""Signal that a Track has been added to the set."""
|
||||
|
||||
@GObject.Signal(arg_types=(int,))
|
||||
def trackid_removed(self, trackid: int) -> None:
|
||||
"""Signal that a Track has been removed from the set."""
|
||||
|
||||
@GObject.Signal
|
||||
def trackids_reset(self) -> None:
|
||||
"""Signal that the Tracks in the set have been reset."""
|
|
@ -0,0 +1,38 @@
|
|||
/* Copyright 2023 (c) Anna Schumaker */
|
||||
|
||||
PRAGMA user_version = 2;
|
||||
|
||||
/*
|
||||
* The `saved_track_data` table is missing the date added field, which
|
||||
* causes restored tracks to show up in the "New Tracks" playlist again.
|
||||
* We can fix this by storing the date that the track was initially added
|
||||
* to the database, and restoring it later.
|
||||
*/
|
||||
|
||||
ALTER TABLE saved_track_data
|
||||
ADD COLUMN added DATE DEFAULT NULL;
|
||||
|
||||
UPDATE saved_track_data SET added = CURRENT_DATE;
|
||||
|
||||
DROP TRIGGER tracks_delete_save;
|
||||
CREATE TRIGGER tracks_delete_save BEFORE DELETE ON tracks
|
||||
WHEN OLD.mbid != "" BEGIN
|
||||
INSERT INTO saved_track_data
|
||||
(mbid, favorite, playcount, lastplayed, laststarted, added)
|
||||
VALUES (OLD.mbid, OLD.favorite, OLD.playcount,
|
||||
OLD.lastplayed, OLD.laststarted, OLD.added);
|
||||
END;
|
||||
|
||||
DROP TRIGGER tracks_insert_restore;
|
||||
CREATE TRIGGER tracks_insert_restore AFTER INSERT ON tracks
|
||||
WHEN NEW.mbid != "" BEGIN
|
||||
UPDATE tracks SET favorite = saved_track_data.favorite,
|
||||
playcount = saved_track_data.playcount,
|
||||
lastplayed = saved_track_data.lastplayed,
|
||||
laststarted = saved_track_data.laststarted,
|
||||
added = saved_track_data.added
|
||||
FROM saved_track_data
|
||||
WHERE tracks.mbid = saved_track_data.mbid AND
|
||||
tracks.mbid = NEW.mbid;
|
||||
DELETE FROM saved_track_data WHERE mbid = NEW.mbid;
|
||||
END;
|
|
@ -0,0 +1,25 @@
|
|||
/* Copyright 2024 (c) Anna Schumaker */
|
||||
|
||||
PRAGMA user_version = 3;
|
||||
|
||||
/*
|
||||
* The `listenbrainz_queue` table is used to store recently played tracks
|
||||
* before submitting them to ListenBrainz. This gives us some form of offline
|
||||
* recovery, since anything in this table needs to be submitted the next time
|
||||
* we can successfully connect. As a bonus, I prepopulate this table using
|
||||
* the last played data from tracks that have already been played when this
|
||||
* table is created.
|
||||
*/
|
||||
|
||||
CREATE TABLE listenbrainz_queue (
|
||||
listenid INTEGER PRIMARY KEY,
|
||||
trackid INTEGER REFERENCES tracks (trackid)
|
||||
ON DELETE CASCADE
|
||||
ON UPDATE CASCADE,
|
||||
timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
|
||||
INSERT INTO listenbrainz_queue (trackid, timestamp)
|
||||
SELECT trackid, lastplayed FROM tracks
|
||||
WHERE lastplayed IS NOT NULL;
|
|
@ -0,0 +1,82 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""A custom Gio.ListModel for managing individual years."""
|
||||
import sqlite3
|
||||
from gi.repository import GObject
|
||||
from . import playlist
|
||||
from . import tracks
|
||||
|
||||
|
||||
class Year(playlist.Playlist):
|
||||
"""Our custom Year object."""
|
||||
|
||||
year = GObject.Property(type=int)
|
||||
|
||||
@property
|
||||
def primary_key(self) -> int:
|
||||
"""Get this year's primary key."""
|
||||
return self.year
|
||||
|
||||
@GObject.Property(type=playlist.Playlist)
|
||||
def parent(self) -> playlist.Playlist | None:
|
||||
"""Get this Year's parent playlist."""
|
||||
return self.table.sql.decades.lookup(self.year)
|
||||
|
||||
|
||||
class Table(playlist.Table):
|
||||
"""Our Year Table."""
|
||||
|
||||
def __init__(self, sql: GObject.TYPE_PYOBJECT, **kwargs):
|
||||
"""Initialize the Years table."""
|
||||
super().__init__(sql=sql, autodelete=True,
|
||||
system_tracks=False, **kwargs)
|
||||
|
||||
def do_add_track(self, year: Year, track: tracks.Track) -> bool:
|
||||
"""Verify adding a Track to the Year playlist."""
|
||||
return track.year == year.year
|
||||
|
||||
def do_construct(self, **kwargs) -> Year:
|
||||
"""Construct a new Year playlist."""
|
||||
return Year(**kwargs)
|
||||
|
||||
def do_get_sort_key(self, year: Year) -> tuple:
|
||||
"""Get the sort key for a specific year."""
|
||||
return year.year
|
||||
|
||||
def do_remove_track(self, year: Year, track: tracks.Track) -> bool:
|
||||
"""Verify removing a Track from the Year playlist."""
|
||||
return True
|
||||
|
||||
def do_sql_delete(self, year: Year) -> sqlite3.Cursor:
|
||||
"""Delete a year."""
|
||||
if year.parent is not None:
|
||||
year.parent.remove_year(year)
|
||||
return self.sql("DELETE FROM years WHERE year=?", year.year)
|
||||
|
||||
def do_sql_glob(self, glob: str) -> sqlite3.Cursor:
|
||||
"""Search for years matching the search text."""
|
||||
return self.sql("SELECT year FROM years_view WHERE name GLOB ?", glob)
|
||||
|
||||
def do_sql_insert(self, year: int) -> sqlite3.Cursor | None:
|
||||
"""Create a new Year playlist."""
|
||||
if self.sql("INSERT INTO years (year) VALUES (?)", year):
|
||||
return self.sql("SELECT * FROM years_view WHERE year=?", year)
|
||||
|
||||
def do_sql_select_all(self) -> sqlite3.Cursor:
|
||||
"""Load Years from the database."""
|
||||
return self.sql("SELECT * FROM years_view")
|
||||
|
||||
def do_sql_select_one(self, year: int) -> sqlite3.Cursor:
|
||||
"""Look up a year."""
|
||||
return self.sql("SELECT year FROM years WHERE year=?", year)
|
||||
|
||||
def do_sql_select_trackids(self, year: Year) -> sqlite3.Cursor:
|
||||
"""Load a Year's Tracks from the database."""
|
||||
return self.sql("""SELECT trackid FROM year_tracks_view
|
||||
WHERE year=?""", year.year)
|
||||
|
||||
def create(self, *args, **kwargs) -> Year | None:
|
||||
"""Create a new Year playlist."""
|
||||
if (year := super().create(*args, **kwargs)) is not None:
|
||||
if year.parent is not None:
|
||||
year.parent.add_year(year)
|
||||
return year
|
|
@ -0,0 +1,99 @@
|
|||
/* Copyright 2022 (c) Anna Schumaker. */
|
||||
|
||||
/* Make the Gtk.Paned separator transparent with extra padding */
|
||||
paned.emmental-pane>separator {
|
||||
opacity: 0;
|
||||
padding: 8px;
|
||||
}
|
||||
|
||||
*.emmental-padding {
|
||||
padding: 8px;
|
||||
}
|
||||
|
||||
box.emmental-splitbutton>button {
|
||||
border-radius: 0%;
|
||||
margin-left: -1px;
|
||||
}
|
||||
|
||||
box.emmental-splitbutton>menubutton>button {
|
||||
border-radius: 0%;
|
||||
margin-left: -1px;
|
||||
padding: 6px;
|
||||
}
|
||||
|
||||
row.emmental-active-row {
|
||||
font-weight: bold;
|
||||
background-color: alpha(@accent_color, 0.15);
|
||||
}
|
||||
|
||||
row.emmental-active-row:hover {
|
||||
background-color: alpha(@accent_color, 0.22);
|
||||
}
|
||||
|
||||
row.emmental-active-row:active {
|
||||
background-color: alpha(@accent_color, 0.31);
|
||||
}
|
||||
|
||||
row.emmental-active-row:selected {
|
||||
background-color: alpha(@accent_color, 0.25);
|
||||
}
|
||||
|
||||
row.emmental-active-row:selected:hover {
|
||||
background-color: alpha(@accent_color, 0.28);
|
||||
}
|
||||
|
||||
row.emmental-active-row:selected:active {
|
||||
background-color: alpha(@accent_color, 0.34);
|
||||
}
|
||||
|
||||
image.emmental-sidebar-arrow {
|
||||
transition: 250ms;
|
||||
transform: rotate(0deg);
|
||||
}
|
||||
|
||||
image.emmental-sidebar-arrow:checked {
|
||||
transition: 250ms;
|
||||
transform: rotate(-180deg);
|
||||
color: @accent_color;
|
||||
}
|
||||
|
||||
box.emmental-sidebar-section>button {
|
||||
border-radius: 0%;
|
||||
margin-top: -1px;
|
||||
}
|
||||
|
||||
button.emmental-delete>image {
|
||||
color: @destructive_color;
|
||||
}
|
||||
|
||||
button.emmental-stop>image {
|
||||
color: @red_3;
|
||||
}
|
||||
|
||||
columnview.emmental-track-list > header {
|
||||
background-color: @card_bg_color;
|
||||
}
|
||||
|
||||
columnview.emmental-track-list > listview {
|
||||
background-color: @card_bg_color;
|
||||
}
|
||||
|
||||
columnview.emmental-track-list > listview > row > cell {
|
||||
padding: 0px 2px;
|
||||
min-height: 40px;
|
||||
}
|
||||
|
||||
columnview.emmental-track-list > listview > row > cell > label {
|
||||
padding: 0px 4px;
|
||||
}
|
||||
|
||||
columnview.emmental-track-list > listview > row > cell > picture {
|
||||
padding: 4px 0px;
|
||||
min-height: 36px;
|
||||
min-width: 36px;
|
||||
border-radius: 15%;
|
||||
}
|
||||
|
||||
box.emmental-move-buttons > button > image {
|
||||
color: @accent_color;
|
||||
}
|
|
@ -0,0 +1,68 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""Customized Gtk.Entries for easier development."""
|
||||
from gi.repository import Gtk
|
||||
from gi.repository import GObject
|
||||
from . import format
|
||||
|
||||
|
||||
class Filter(Gtk.SearchEntry):
|
||||
"""A Gtk.Entry that returns a filter query."""
|
||||
|
||||
def __init__(self, what: str, **kwargs):
|
||||
"""Set up the FilterEntry."""
|
||||
super().__init__(placeholder_text=f"type to filter {what}", **kwargs)
|
||||
|
||||
def get_placeholder_text(self) -> str:
|
||||
"""Get the entry's placeholder-text."""
|
||||
return self.get_property("placeholder-text")
|
||||
|
||||
def get_query(self) -> str | None:
|
||||
"""Get the query string for the entered text."""
|
||||
return format.search(self.get_text())
|
||||
|
||||
|
||||
class ValueBase(Gtk.Entry):
|
||||
"""Base class for value entries."""
|
||||
|
||||
def __init__(self, input_purpose: Gtk.InputPurpose, value, **kwargs):
|
||||
"""Initialize a ValueBase Entry."""
|
||||
super().__init__(input_purpose=input_purpose,
|
||||
value=value, text=str(value), **kwargs)
|
||||
self.connect("notify::value", self.__notify_value)
|
||||
|
||||
def __notify_value(self, entry: Gtk.Entry, param) -> None:
|
||||
self.set_text(str(self.value))
|
||||
|
||||
def do_activate(self) -> None:
|
||||
"""Handle the activate signal."""
|
||||
self.value = type(self.value)(self.get_text())
|
||||
|
||||
|
||||
class Integer(ValueBase):
|
||||
"""Entry for Integers."""
|
||||
|
||||
value = GObject.Property(type=int)
|
||||
|
||||
def __init__(self, value: int = 0, **kwargs):
|
||||
"""Initialize an Integer Entry."""
|
||||
super().__init__(Gtk.InputPurpose.DIGITS, value, **kwargs)
|
||||
|
||||
|
||||
class Float(ValueBase):
|
||||
"""Entry for Floats."""
|
||||
|
||||
value = GObject.Property(type=float)
|
||||
|
||||
def __init__(self, value: float = 0.0, **kwargs):
|
||||
"""Initialize a Float Entry."""
|
||||
super().__init__(Gtk.InputPurpose.NUMBER, value, **kwargs)
|
||||
|
||||
|
||||
class String(ValueBase):
|
||||
"""Entry for Strings."""
|
||||
|
||||
value = GObject.Property(type=str)
|
||||
|
||||
def __init__(self, value: str = "", **kwargs):
|
||||
"""Initialize a String Entry."""
|
||||
super().__init__(Gtk.InputPurpose.FREE_FORM, value, **kwargs)
|
|
@ -0,0 +1,201 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""A customized Gtk.SignalListItemFactory for easier use."""
|
||||
import typing
|
||||
from gi.repository import GObject
|
||||
from gi.repository import Gio
|
||||
from gi.repository import Gtk
|
||||
|
||||
|
||||
class ListRow(GObject.GObject):
|
||||
"""Extra state that we attach to the Gtk.ListItem."""
|
||||
|
||||
listitem = GObject.Property(type=Gtk.ListItem)
|
||||
|
||||
def __init__(self, listitem: Gtk.ListItem, **kwargs):
|
||||
"""Initialize a ListRow object."""
|
||||
GObject.GObject.__init__(self, listitem=listitem, **kwargs)
|
||||
self.bindings = []
|
||||
|
||||
def do_bind(self) -> None:
|
||||
"""Bind the list item to the child widget."""
|
||||
|
||||
def do_unbind(self) -> None:
|
||||
"""Unbind the list item from the child widget."""
|
||||
|
||||
def bind_active(self, item_prop: str) -> None:
|
||||
"""Bind a property to the Row's active property."""
|
||||
self.bind_and_set(self.item, item_prop, self, "active")
|
||||
|
||||
def bind_and_set(self, src: GObject.GObject, src_prop: str,
|
||||
dst: GObject.GObject, dst_prop: str,
|
||||
bidirectional: bool = False,
|
||||
invert_boolean: bool = False) -> None:
|
||||
"""Bind and set a property from the src object to the dst object."""
|
||||
f_bidir = GObject.BindingFlags.BIDIRECTIONAL if bidirectional else 0
|
||||
f_invrt = GObject.BindingFlags.INVERT_BOOLEAN if invert_boolean else 0
|
||||
|
||||
src_value = src.get_property(src_prop)
|
||||
value = not src_value if invert_boolean else src_value
|
||||
dst.set_property(dst_prop, value)
|
||||
self.bindings.append(src.bind_property(src_prop, dst, dst_prop,
|
||||
f_bidir | f_invrt))
|
||||
|
||||
def bind_and_set_property(self, item_prop: str, child_prop: str,
|
||||
bidirectional: bool = False,
|
||||
invert_boolean: bool = False) -> None:
|
||||
"""Bind and set a list item property."""
|
||||
self.bind_and_set(self.item, item_prop, self.child, child_prop,
|
||||
bidirectional, invert_boolean)
|
||||
|
||||
def bind(self) -> None:
|
||||
"""Bind the list item to the child widget."""
|
||||
self.do_bind()
|
||||
|
||||
def unbind(self) -> None:
|
||||
"""Unbind the list item from the child widget."""
|
||||
for binding in self.bindings:
|
||||
binding.unbind()
|
||||
self.bindings.clear()
|
||||
self.do_unbind()
|
||||
|
||||
@GObject.Property(type=bool, default=False)
|
||||
def active(self) -> bool:
|
||||
"""Get the active state of this Row."""
|
||||
if self.listrow is not None:
|
||||
return self.listrow.has_css_class("emmental-active-row")
|
||||
return False
|
||||
|
||||
@active.setter
|
||||
def active(self, newval: bool) -> None:
|
||||
if self.listrow is not None:
|
||||
if newval:
|
||||
self.listrow.add_css_class("emmental-active-row")
|
||||
else:
|
||||
self.listrow.remove_css_class("emmental-active-row")
|
||||
|
||||
@GObject.Property(type=Gtk.Widget)
|
||||
def child(self) -> Gtk.Widget | None:
|
||||
"""Get the child widget displayed by this Row."""
|
||||
return self.listitem.get_child()
|
||||
|
||||
@child.setter
|
||||
def child(self, newval: Gtk.Widget) -> None:
|
||||
self.listitem.set_child(newval)
|
||||
|
||||
@GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
def item(self) -> GObject.TYPE_PYOBJECT:
|
||||
"""Get the list item for this Row."""
|
||||
return self.listitem.get_item()
|
||||
|
||||
@GObject.Property(type=Gtk.Widget)
|
||||
def listrow(self) -> Gtk.Widget:
|
||||
"""Get the listrow widget that our child widget is contained in."""
|
||||
return self.listitem.props.child.props.parent
|
||||
|
||||
|
||||
class InscriptionRow(ListRow):
|
||||
"""A ListRow for displaying Gtk.Inscription widgets."""
|
||||
|
||||
item_property = GObject.Property(type=str)
|
||||
|
||||
def __init__(self, listitem: Gtk.ListItem, item_property: str,
|
||||
xalign: float = 0.0, numeric: bool = False) -> None:
|
||||
"""Create a new Gtk.Label."""
|
||||
super().__init__(listitem, item_property=item_property)
|
||||
self.child = Gtk.Inscription(xalign=xalign)
|
||||
if numeric:
|
||||
self.child.add_css_class("numeric")
|
||||
|
||||
def do_bind(self) -> None:
|
||||
"""Bind a ListItem to the Label."""
|
||||
self.bind_and_set_property(self.item_property, "text")
|
||||
|
||||
|
||||
class TreeRow(ListRow):
|
||||
"""A ListRow for displaying child widgets in a Tree."""
|
||||
|
||||
n_children = GObject.Property(type=int)
|
||||
have_children = GObject.Property(type=bool, default=False)
|
||||
indented = GObject.Property(type=bool, default=True)
|
||||
|
||||
def __init__(self, listitem: Gtk.ListItem, **kwargs) -> None:
|
||||
"""Create a new TreeRow."""
|
||||
super().__init__(listitem, **kwargs)
|
||||
listitem.set_child(Gtk.TreeExpander(hide_expander=True,
|
||||
indent_for_icon=self.indented))
|
||||
self.bind_property("n-children", self, "have-children")
|
||||
self.bind_property("have-children", listitem.get_child(),
|
||||
"hide-expander",
|
||||
GObject.BindingFlags.INVERT_BOOLEAN)
|
||||
self.bind_property("indented", listitem.get_child(), "indent-for-icon")
|
||||
|
||||
def bind(self) -> None:
|
||||
"""Bind a TreeRow to the TreeExpander."""
|
||||
self.listitem.get_child().set_list_row(self.listitem.get_item())
|
||||
super().bind()
|
||||
|
||||
def bind_n_children(self, children: Gio.ListModel | None) -> None:
|
||||
"""Bind to the n-items property of the child listmodel."""
|
||||
if children is not None:
|
||||
self.bind_and_set(children, "n-items", self, "n-children")
|
||||
|
||||
def unbind(self) -> None:
|
||||
"""Unbind a TreeRow from the TreeExpander."""
|
||||
self.listitem.get_child().set_list_row(None)
|
||||
super().unbind()
|
||||
|
||||
@GObject.Property(type=Gtk.Widget)
|
||||
def child(self) -> Gtk.Widget | None:
|
||||
"""Get the child widget displayed by this Row."""
|
||||
return self.listitem.get_child().get_child()
|
||||
|
||||
@child.setter
|
||||
def child(self, newval=Gtk.Widget) -> None:
|
||||
self.listitem.get_child().set_child(newval)
|
||||
|
||||
@GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
def item(self) -> GObject.TYPE_PYOBJECT:
|
||||
"""Get the list item for this Row."""
|
||||
return self.listitem.get_item().get_item()
|
||||
|
||||
|
||||
class Factory(Gtk.SignalListItemFactory):
|
||||
"""A customized Factory for making list row widgets."""
|
||||
|
||||
def __init__(self, row_type: typing.Type[ListRow], **kwargs):
|
||||
"""Initialize a ListFactory."""
|
||||
super().__init__()
|
||||
self.row_type = row_type
|
||||
|
||||
self.connect("setup", self.__setup, kwargs)
|
||||
self.connect("bind", self.__bind)
|
||||
self.connect("unbind", self.__unbind)
|
||||
self.connect("teardown", self.__teardown)
|
||||
|
||||
def __setup(self, factory: Gtk.SignalListItemFactory,
|
||||
listitem: Gtk.ListItem, kwargs: dict) -> None:
|
||||
listitem.listrow = self.row_type(listitem, **kwargs)
|
||||
|
||||
def __bind(self, factory: Gtk.SignalListItemFactory,
|
||||
listitem: Gtk.ListItem) -> None:
|
||||
listitem.listrow.bind()
|
||||
|
||||
def __unbind(self, factory: Gtk.SignalListItemFactory,
|
||||
listitem: Gtk.ListItem) -> None:
|
||||
listitem.listrow.unbind()
|
||||
|
||||
def __teardown(self, factory: Gtk.SignalListItemFactory,
|
||||
listitem: Gtk.ListItem) -> None:
|
||||
listitem.set_child(None)
|
||||
listitem.listrow = None
|
||||
|
||||
|
||||
class InscriptionFactory(Factory):
|
||||
"""A Factory that creates InscriptionRows."""
|
||||
|
||||
def __init__(self, item_property: str,
|
||||
script_type: typing.Type[InscriptionRow] = InscriptionRow,
|
||||
xalign: float = 0.0, numeric: bool = False):
|
||||
"""Initialize a LabelFactory."""
|
||||
super().__init__(row_type=script_type, item_property=item_property,
|
||||
xalign=xalign, numeric=numeric)
|
|
@ -0,0 +1,35 @@
|
|||
# Copyright 2022 (c) Anna Schumaker
|
||||
"""Helper functions for formatting strings."""
|
||||
import re
|
||||
|
||||
IGNORE_WORDS = set(["a", "an", "the", ""])
|
||||
|
||||
|
||||
def search(input: str) -> str | None:
|
||||
"""Translate the input string into a sqlite3 GLOB statement."""
|
||||
input = input.strip().casefold()
|
||||
if len(input) == 0:
|
||||
return None
|
||||
|
||||
if input[0] == "^":
|
||||
input = input[1:] if len(input) > 1 else "*"
|
||||
elif input[0] != "*":
|
||||
input = "*" + input
|
||||
|
||||
if input[-1] == "$":
|
||||
input = input[:-1]
|
||||
elif input[-1] != "*":
|
||||
input += "*"
|
||||
|
||||
return input
|
||||
|
||||
|
||||
def sort_key(input: str) -> tuple:
|
||||
"""Translate the input string into a sort key."""
|
||||
if len(input) == 0:
|
||||
return ()
|
||||
input = re.sub(r"[\"\'’“”]", "", input.casefold())
|
||||
res = re.split(r"[ /_-]", input)
|
||||
if len(res) > 1 and res[0] in IGNORE_WORDS:
|
||||
res = res[1:]
|
||||
return tuple(res)
|
|
@ -0,0 +1,80 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""Set up GObject Introspection, and custom styling, and icons."""
|
||||
import pathlib
|
||||
import sys
|
||||
import sqlite3
|
||||
import gi
|
||||
import xdg.BaseDirectory
|
||||
|
||||
gi.require_version("Pango", "1.0")
|
||||
gi.require_version("Gdk", "4.0")
|
||||
gi.require_version("Gtk", "4.0")
|
||||
gi.require_version("Adw", "1")
|
||||
gi.require_version("Gst", "1.0")
|
||||
|
||||
gi.importlib.import_module("gi.repository.Gio")
|
||||
gi.importlib.import_module("gi.repository.Gtk")
|
||||
gi.importlib.import_module("gi.repository.Gst").init(sys.argv)
|
||||
|
||||
DEBUG_STR = "-debug" if __debug__ else ""
|
||||
APPLICATION_ID = f"com.nowheycreamery.emmental{DEBUG_STR}"
|
||||
|
||||
CSS_FILE = pathlib.Path(__file__).parent / "emmental.css"
|
||||
CSS_PRIORITY = gi.repository.Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
|
||||
CSS_PROVIDER = gi.repository.Gtk.CssProvider()
|
||||
CSS_PROVIDER.load_from_path(str(CSS_FILE))
|
||||
|
||||
CACHE_DIR = pathlib.Path(xdg.BaseDirectory.save_cache_path("emmental"))
|
||||
CACHE_DIR = CACHE_DIR / DEBUG_STR.lstrip("-")
|
||||
|
||||
DATA_DIR = pathlib.Path(xdg.BaseDirectory.save_data_path("emmental"))
|
||||
|
||||
RESOURCE_PATH = "/com/nowheycreamery/emmental"
|
||||
RESOURCE_ICONS = f"{RESOURCE_PATH}/icons/scalable/apps"
|
||||
RESOURCE_FILE = pathlib.Path(__file__).parent.parent / "emmental.gresource"
|
||||
RESOURCE = gi.repository.Gio.Resource.load(str(RESOURCE_FILE))
|
||||
gi.repository.Gio.resources_register(RESOURCE)
|
||||
|
||||
|
||||
def add_style():
|
||||
"""Add our stylesheet to the default display."""
|
||||
style = gi.repository.Gtk.StyleContext
|
||||
style.add_provider_for_display(gi.repository.Gdk.Display.get_default(),
|
||||
CSS_PROVIDER, CSS_PRIORITY)
|
||||
|
||||
|
||||
def has_icon(icon_name: str):
|
||||
"""Check if the icon theme has a specific icon."""
|
||||
display = gi.repository.Gdk.Display.get_default()
|
||||
theme = gi.repository.Gtk.IconTheme.get_for_display(display)
|
||||
return theme.has_icon(icon_name)
|
||||
|
||||
|
||||
def __version_string(subsystem, major, minor, micro):
|
||||
return f" ⋅ {subsystem} {major}.{minor}.{micro}"
|
||||
|
||||
|
||||
def env_string() -> str:
|
||||
"""Return a string with the version numbers of our dependencies."""
|
||||
gst = gi.repository.Gst.version()
|
||||
strs = [__version_string("Python", sys.version_info.major,
|
||||
sys.version_info.minor, sys.version_info.micro),
|
||||
__version_string("Gtk", gi.repository.Gtk.MAJOR_VERSION,
|
||||
gi.repository.Gtk.MINOR_VERSION,
|
||||
gi.repository.Gtk.MICRO_VERSION),
|
||||
__version_string("Libadwaita", gi.repository.Adw.MAJOR_VERSION,
|
||||
gi.repository.Adw.MINOR_VERSION,
|
||||
gi.repository.Adw.MICRO_VERSION),
|
||||
__version_string("GStreamer", gst.major, gst.minor, gst.micro),
|
||||
__version_string("Pango", gi.repository.Pango.VERSION_MAJOR,
|
||||
gi.repository.Pango.VERSION_MINOR,
|
||||
gi.repository.Pango.VERSION_MICRO),
|
||||
__version_string("SQLite", sqlite3.sqlite_version_info[0],
|
||||
sqlite3.sqlite_version_info[1],
|
||||
sqlite3.sqlite_version_info[2])]
|
||||
return "\n".join(strs)
|
||||
|
||||
|
||||
def print_env() -> None:
|
||||
"""Print the environment versions to stdout."""
|
||||
print(env_string())
|
|
@ -0,0 +1,185 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""A custom Gtk.HeaderBar configured for our application."""
|
||||
import pathlib
|
||||
import typing
|
||||
from gi.repository import GObject
|
||||
from gi.repository import Gtk
|
||||
from gi.repository import Adw
|
||||
from ..action import ActionEntry
|
||||
from .. import db
|
||||
from .. import buttons
|
||||
from .. import gsetup
|
||||
from . import listenbrainz
|
||||
from . import open
|
||||
from . import replaygain
|
||||
from . import volume
|
||||
if __debug__:
|
||||
from . import settings
|
||||
|
||||
SUBTITLE = "The Cheesy Music Player"
|
||||
|
||||
|
||||
def _volume_icon(vol: float) -> str:
|
||||
if vol == 0.0:
|
||||
return "audio-volume-muted-symbolic"
|
||||
if vol <= 1/3:
|
||||
return "audio-volume-low-symbolic"
|
||||
if vol <= 2/3:
|
||||
return "audio-volume-medium-symbolic"
|
||||
return "audio-volume-high-symbolic"
|
||||
|
||||
|
||||
class Header(Gtk.HeaderBar):
|
||||
"""Our custom Gtk.HeaderBar containing window title and volume controls."""
|
||||
|
||||
sql = GObject.Property(type=db.Connection)
|
||||
title = GObject.Property(type=str)
|
||||
subtitle = GObject.Property(type=str)
|
||||
listenbrainz_token = GObject.Property(type=str)
|
||||
show_sidebar = GObject.Property(type=bool, default=False)
|
||||
bg_enabled = GObject.Property(type=bool, default=False)
|
||||
bg_volume = GObject.Property(type=float, default=0.5)
|
||||
rg_enabled = GObject.Property(type=bool, default=False)
|
||||
rg_mode = GObject.Property(type=str, default="auto")
|
||||
volume = GObject.Property(type=float, default=1.0)
|
||||
|
||||
def __init__(self, sql: db.Connection, title: str):
|
||||
"""Initialize the HeaderBar."""
|
||||
super().__init__(title=title, subtitle=SUBTITLE, sql=sql)
|
||||
self._title = Adw.WindowTitle(title=self.title, subtitle=self.subtitle,
|
||||
tooltip_text=gsetup.env_string())
|
||||
|
||||
icon = "sidebar-show-symbolic"
|
||||
self._show_sidebar = Gtk.ToggleButton(icon_name=icon, has_frame=False)
|
||||
self._open = open.OpenRow()
|
||||
self._listenbrainz = listenbrainz.ListenBrainzRow()
|
||||
|
||||
self._menu_box = Gtk.ListBox(selection_mode=Gtk.SelectionMode.NONE)
|
||||
self._menu_box.add_css_class("boxed-list")
|
||||
self._menu_box.append(self._open)
|
||||
self._menu_box.append(self._listenbrainz)
|
||||
|
||||
if __debug__:
|
||||
self._settings = settings.Row(sql)
|
||||
self._menu_box.append(self._settings)
|
||||
|
||||
icon = "open-menu-symbolic"
|
||||
self._menu_button = buttons.PopoverButton(popover_child=self._menu_box,
|
||||
icon_name=icon)
|
||||
|
||||
self._volume = volume.VolumeRow()
|
||||
self._volume_icon = Gtk.Image(icon_name=_volume_icon(self.volume))
|
||||
self._background = volume.BackgroundRow()
|
||||
self._background_icon = Gtk.Image(icon_name="sound-wave")
|
||||
self._replaygain = replaygain.ReplayGainRow()
|
||||
|
||||
self._icons = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 6)
|
||||
self._icons.append(self._volume_icon)
|
||||
self._icons.append(self._background_icon)
|
||||
|
||||
self._vol_box = Gtk.ListBox(selection_mode=Gtk.SelectionMode.NONE)
|
||||
self._vol_box.add_css_class("boxed-list")
|
||||
self._vol_box.append(self._volume)
|
||||
self._vol_box.append(self._background)
|
||||
self._vol_box.append(self._replaygain)
|
||||
|
||||
self._vol_button = buttons.PopoverButton(popover_child=self._vol_box,
|
||||
child=self._icons,
|
||||
has_frame=False, margin_end=6)
|
||||
|
||||
self.bind_property("title", self._title, "title")
|
||||
self.bind_property("subtitle", self._title, "subtitle")
|
||||
self.bind_property("listenbrainz-token", self._listenbrainz, "text")
|
||||
self.bind_property("show-sidebar", self._show_sidebar, "active",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
self.bind_property("bg-enabled", self._background, "enabled",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
self.bind_property("bg-volume", self._background, "volume",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
self.bind_property("rg-enabled", self._replaygain, "enabled",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
self.bind_property("rg-mode", self._replaygain, "mode",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
self.bind_property("volume", self._volume, "volume",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
|
||||
self.pack_start(self._show_sidebar)
|
||||
self.pack_start(self._menu_button)
|
||||
|
||||
self.pack_end(self._vol_button)
|
||||
self.set_title_widget(self._title)
|
||||
|
||||
self._menu_button.props.popover.connect("closed", self.__menu_closed)
|
||||
self._open.connect("track-requested", self.__track_requested)
|
||||
self._listenbrainz.connect("apply", self.__listenbrainz_apply)
|
||||
self.connect("notify", self.__notify)
|
||||
|
||||
def __run_settings(self, button: Gtk.Button) -> None:
|
||||
if __debug__:
|
||||
self._window.present()
|
||||
|
||||
def __notify(self, header: typing.Self, param: GObject.ParamSpec) -> None:
|
||||
match param.name:
|
||||
case "bg-enabled":
|
||||
icon = "sound-wave-alt" if self.bg_enabled else "sound-wave"
|
||||
self._background_icon.set_from_icon_name(icon)
|
||||
case "volume":
|
||||
self._volume_icon.set_from_icon_name(_volume_icon(self.volume))
|
||||
|
||||
bg_status = "off"
|
||||
if self.bg_enabled:
|
||||
bg_status = f"{round(self.bg_volume * 100)}%"
|
||||
|
||||
rg_status = f"{self.rg_mode} mode" if self.rg_enabled else "off"
|
||||
status = (f"volume: {round(self.volume * 100)}%\n"
|
||||
f"background listening: {bg_status}\n"
|
||||
f"normalizing: {rg_status}")
|
||||
self._vol_button.set_tooltip_text(status)
|
||||
|
||||
def __listenbrainz_apply(self, entry: Adw.PasswordEntryRow) -> None:
|
||||
self.listenbrainz_token = entry.get_text()
|
||||
self._menu_button.popdown()
|
||||
|
||||
def __menu_closed(self, popover: Gtk.Popover) -> None:
|
||||
self._listenbrainz.props.text = self.listenbrainz_token
|
||||
|
||||
def __track_requested(self, button: open.OpenRow,
|
||||
path: pathlib.Path) -> None:
|
||||
self.emit("track-requested", path)
|
||||
|
||||
@GObject.Property(type=bool, default=True)
|
||||
def listenbrainz_token_valid(self) -> bool:
|
||||
"""Check if we think the listenbrainz token is valid."""
|
||||
return not self._listenbrainz.has_css_class("warning")
|
||||
|
||||
@listenbrainz_token_valid.setter
|
||||
def listenbrainz_token_valid(self, valid: bool) -> None:
|
||||
if valid:
|
||||
self._menu_button.remove_css_class("warning")
|
||||
self._listenbrainz.remove_css_class("warning")
|
||||
else:
|
||||
win = self.get_ancestor(Gtk.Window)
|
||||
win.post_toast("listenbrainz: user token is invalid")
|
||||
self._menu_button.add_css_class("warning")
|
||||
self._listenbrainz.add_css_class("warning")
|
||||
|
||||
@property
|
||||
def accelerators(self) -> list[ActionEntry]:
|
||||
"""Get a list of accelerators for the Header."""
|
||||
res = [ActionEntry("open-file", self._open.activate, "<Control>o"),
|
||||
ActionEntry("decrease-volume", self._volume.decrement,
|
||||
"<Shift><Control>Down"),
|
||||
ActionEntry("increase-volume", self._volume.increment,
|
||||
"<Shift><Control>Up"),
|
||||
ActionEntry("toggle-bg-mode", self._background.activate,
|
||||
"<Shift><Control>b"),
|
||||
ActionEntry("toggle-sidebar", self._show_sidebar.activate,
|
||||
"<Control>bracketright")]
|
||||
if __debug__:
|
||||
res.append(ActionEntry("edit-settings", self._settings.activate,
|
||||
"<Shift><Control>s"))
|
||||
return res
|
||||
|
||||
@GObject.Signal(arg_types=(GObject.TYPE_PYOBJECT,))
|
||||
def track_requested(self, path: pathlib.Path) -> None:
|
||||
"""Signal that a track has been requested."""
|
|
@ -0,0 +1,14 @@
|
|||
# Copyright 2024 (c) Anna Schumaker.
|
||||
"""A custom Adw.PasswordEntryRow to set the user token."""
|
||||
from gi.repository import Gtk
|
||||
from gi.repository import Adw
|
||||
|
||||
|
||||
def ListenBrainzRow() -> Adw.PasswordEntryRow:
|
||||
"""Create a new PasswordEntryRow for entering the user token."""
|
||||
row = Adw.PasswordEntryRow(title="ListenBrainz User Token",
|
||||
show_apply_button=True)
|
||||
row.prefix = Gtk.Image(icon_name="listenbrainz-logo-symbolic")
|
||||
|
||||
row.add_prefix(row.prefix)
|
||||
return row
|
|
@ -0,0 +1,46 @@
|
|||
# Copyright 2023 (c) Anna Schumaker.
|
||||
"""A custom Adw.ActionRow to select a file for playback."""
|
||||
import pathlib
|
||||
from gi.repository import GObject
|
||||
from gi.repository import GLib
|
||||
from gi.repository import Gio
|
||||
from gi.repository import Gtk
|
||||
from gi.repository import Adw
|
||||
|
||||
|
||||
class OpenRow(Adw.ActionRow):
|
||||
"""Our pre-configured open Adw.ActionRow."""
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize our open ActionRow."""
|
||||
super().__init__(activatable=True, title="Open File",
|
||||
subtitle="Select a file for playback")
|
||||
self._prefix = Gtk.Image(icon_name="document-open-symbolic")
|
||||
self._filters = Gio.ListStore()
|
||||
self._filter = Gtk.FileFilter(name="Audio Files",
|
||||
mime_types=["inode/directory",
|
||||
"audio/*"])
|
||||
self._dialog = Gtk.FileDialog(filters=self._filters,
|
||||
title="Pick a Track")
|
||||
|
||||
self._filters.append(self._filter)
|
||||
|
||||
self.connect("activated", self.__on_activated)
|
||||
self.add_prefix(self._prefix)
|
||||
|
||||
def __async_ready(self, dialog: Gtk.FileDialog, task: Gio.Task) -> None:
|
||||
try:
|
||||
file = dialog.open_finish(task)
|
||||
self.emit("track-requested", pathlib.Path(file.get_path()))
|
||||
except GLib.Error:
|
||||
pass
|
||||
|
||||
def __on_activated(self, row: Adw.ActionRow) -> None:
|
||||
"""Handle activating an OpenRow."""
|
||||
self.get_ancestor(Gtk.Popover).popdown()
|
||||
self._dialog.open(self.get_ancestor(Gtk.Window), None,
|
||||
self.__async_ready)
|
||||
|
||||
@GObject.Signal(arg_types=(GObject.TYPE_PYOBJECT,))
|
||||
def track_requested(self, file: pathlib.Path) -> None:
|
||||
"""Signal that a track has been requested."""
|
|
@ -0,0 +1,78 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""A widget for selecting ReplayGain mode."""
|
||||
from gi.repository import GObject
|
||||
from gi.repository import Gtk
|
||||
from gi.repository import Adw
|
||||
|
||||
|
||||
class CheckRow(Adw.ActionRow):
|
||||
"""A custom Adw.ActionRow displaying a Check Button."""
|
||||
|
||||
active = GObject.Property(type=bool, default=False)
|
||||
group = GObject.Property(type=Adw.ActionRow)
|
||||
mode = GObject.Property(type=str)
|
||||
|
||||
def __init__(self, mode: str, active: bool = False,
|
||||
group: Adw.ActionRow | None = None, **kwargs):
|
||||
"""Initialize the Check Row."""
|
||||
super().__init__(mode=mode, active=active, group=group, **kwargs)
|
||||
self._prefix = Gtk.CheckButton(active=active,
|
||||
group=group._prefix if group else None)
|
||||
|
||||
self.bind_property("active", self._prefix, "active",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
|
||||
self.set_activatable_widget(self._prefix)
|
||||
self.add_prefix(self._prefix)
|
||||
|
||||
def set_active(self, newval: bool) -> None:
|
||||
"""Set the active property."""
|
||||
if self.active != newval:
|
||||
self.active = newval
|
||||
|
||||
|
||||
class ReplayGainRow(Adw.ExpanderRow):
|
||||
"""Build up a widget for configuring ReplayGain settings."""
|
||||
|
||||
enabled = GObject.Property(type=bool, default=False)
|
||||
mode = GObject.Property(type=str, default="auto")
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize the ReplayGain selector."""
|
||||
super().__init__(title="Volume Normalization",
|
||||
subtitle="Configure ReplayGain normalizing")
|
||||
self._switch = Gtk.Switch(valign=Gtk.Align.CENTER)
|
||||
self._automatic = CheckRow(title="Automatic Mode",
|
||||
subtitle="Emmental decides automatically",
|
||||
mode="auto", active=True)
|
||||
self._album = CheckRow(title="Album Mode",
|
||||
subtitle="Albums have the same volume",
|
||||
mode="album", group=self._automatic)
|
||||
self._track = CheckRow(title="Track Mode",
|
||||
subtitle="Tracks have the same volume",
|
||||
mode="track", group=self._automatic)
|
||||
|
||||
self.add_prefix(self._switch)
|
||||
self.add_row(self._automatic)
|
||||
self.add_row(self._album)
|
||||
self.add_row(self._track)
|
||||
|
||||
self.connect("notify::mode", self.__notify_mode)
|
||||
self._automatic.connect("notify::active", self.__row_activated)
|
||||
self._album.connect("notify::active", self.__row_activated)
|
||||
self._track.connect("notify::active", self.__row_activated)
|
||||
|
||||
self._switch.bind_property("active", self, "expanded",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
self.bind_property("enabled", self._switch, "active",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
|
||||
def __notify_mode(self, row: Adw.ExpanderRow, param) -> None:
|
||||
match self.mode:
|
||||
case "album": self._album.set_active(True)
|
||||
case "track": self._track.set_active(True)
|
||||
case _: self._automatic.set_active(True)
|
||||
|
||||
def __row_activated(self, row: CheckRow, param: GObject.ParamSpec) -> None:
|
||||
if row.active:
|
||||
self.mode = row.mode
|
|
@ -0,0 +1,84 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""A custom Gtk.Dialog for showing Settings."""
|
||||
from gi.repository import Gtk
|
||||
from gi.repository import Adw
|
||||
from .. import db
|
||||
from .. import entry
|
||||
from .. import factory
|
||||
|
||||
|
||||
class ValueRow(factory.ListRow):
|
||||
"""A Row for displaying settings values."""
|
||||
|
||||
def do_bind(self) -> None:
|
||||
"""Bind a db.Setting to this Row."""
|
||||
if isinstance(self.item.value, bool):
|
||||
self.child = Gtk.Switch(halign=Gtk.Align.START)
|
||||
self.bind_and_set_property("value", "active", bidirectional=True)
|
||||
elif isinstance(self.item.value, str):
|
||||
self.child = entry.String(has_frame=False)
|
||||
self.bind_and_set_property("value", "value", bidirectional=True)
|
||||
elif isinstance(self.item.value, int):
|
||||
self.child = entry.Integer(has_frame=False)
|
||||
self.bind_and_set_property("value", "value", bidirectional=True)
|
||||
elif isinstance(self.item.value, float):
|
||||
self.child = entry.Float(has_frame=False)
|
||||
self.bind_and_set_property("value", "value", bidirectional=True)
|
||||
|
||||
|
||||
class Window(Adw.Window):
|
||||
"""A custom window that displays the current settings."""
|
||||
|
||||
def __init__(self, sql: db.Connection):
|
||||
"""Initialize the Settings window."""
|
||||
super().__init__(default_width=500, default_height=500,
|
||||
title="Emmental Settings", icon_name="settings",
|
||||
hide_on_close=True,
|
||||
content=Gtk.Box.new(Gtk.Orientation.VERTICAL, 0))
|
||||
self._search = entry.Filter(what="settings")
|
||||
self._header = Gtk.HeaderBar(title_widget=self._search)
|
||||
self._selection = Gtk.NoSelection(model=sql.settings)
|
||||
self._view = Gtk.ColumnView(model=self._selection,
|
||||
show_row_separators=True)
|
||||
self._scroll = Gtk.ScrolledWindow(child=self._view, vexpand=True)
|
||||
|
||||
self._scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
|
||||
|
||||
self.__append_column(factory.InscriptionFactory("key"),
|
||||
"Key", width=400)
|
||||
self.__append_column(factory.Factory(row_type=ValueRow),
|
||||
"Value", width=100)
|
||||
|
||||
self.get_content().append(self._header)
|
||||
self.get_content().append(self._scroll)
|
||||
|
||||
if __debug__:
|
||||
self.add_css_class("devel")
|
||||
self._search.connect("search-changed", self.__filter)
|
||||
|
||||
def __append_column(self, factory: factory.Factory,
|
||||
title: str, *, width: int) -> None:
|
||||
self._view.append_column(Gtk.ColumnViewColumn(factory=factory,
|
||||
title=title,
|
||||
fixed_width=width))
|
||||
|
||||
def __filter(self, entry: entry.Filter) -> None:
|
||||
self._selection.get_model().filter(entry.get_query())
|
||||
|
||||
|
||||
class Row(Adw.ActionRow):
|
||||
"""An Adw.ActionRow for opening the Settings Window."""
|
||||
|
||||
def __init__(self, sql: db.Connection):
|
||||
"""Initialize our settings ActionRow."""
|
||||
super().__init__(activatable=True, title="Edit Settings",
|
||||
subtitle="Open the settings editor (debug only)")
|
||||
self._prefix = Gtk.Image(icon_name="settings-symbolic")
|
||||
self._window = Window(sql)
|
||||
|
||||
self.connect("activated", self.__on_activated)
|
||||
self.add_prefix(self._prefix)
|
||||
|
||||
def __on_activated(self, row: Adw.ActionRow) -> None:
|
||||
self.get_ancestor(Gtk.Popover).popdown()
|
||||
self._window.present()
|
|
@ -0,0 +1,84 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""A custom Gtk.Box with controls for adjusting the volume."""
|
||||
from gi.repository import GObject
|
||||
from gi.repository import Gtk
|
||||
from gi.repository import Adw
|
||||
|
||||
STEP_SIZE = 0.05
|
||||
|
||||
|
||||
def format_value_func(scale, value: float) -> str:
|
||||
"""Format the volume value to a percentage."""
|
||||
return f"{round(value*100)} %"
|
||||
|
||||
|
||||
class VolumeRow(Gtk.ListBoxRow):
|
||||
"""A Gtk.Box containing widgets for adjusting the volume."""
|
||||
|
||||
volume = GObject.Property(type=float, default=1.0)
|
||||
|
||||
def __init__(self, volume: float = 1.0):
|
||||
"""Initialize our volume controls."""
|
||||
super().__init__(volume=volume)
|
||||
self._box = Gtk.Box()
|
||||
self._decrement = Gtk.Button(icon_name="list-remove-symbolic",
|
||||
tooltip_text="reduce the volume",
|
||||
valign=Gtk.Align.END, has_frame=False,
|
||||
margin_bottom=5)
|
||||
self._adjustment = Gtk.Adjustment.new(volume, 0.0, 1.0,
|
||||
STEP_SIZE, 0, 0)
|
||||
self._scale = Gtk.Scale(adjustment=self._adjustment, draw_value=True,
|
||||
valign=Gtk.Align.END, hexpand=True)
|
||||
self._increment = Gtk.Button(icon_name="list-add-symbolic",
|
||||
tooltip_text="increase the volume",
|
||||
valign=Gtk.Align.END, has_frame=False,
|
||||
margin_bottom=5)
|
||||
|
||||
self._scale.set_format_value_func(format_value_func)
|
||||
|
||||
self._box.append(self._decrement)
|
||||
self._box.append(self._scale)
|
||||
self._box.append(self._increment)
|
||||
self.set_child(self._box)
|
||||
|
||||
self._decrement.connect("clicked", self.decrement)
|
||||
self._scale.connect("value-changed", self.__value_changed)
|
||||
self._increment.connect("clicked", self.increment)
|
||||
|
||||
self.bind_property("volume", self._adjustment, "value",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
|
||||
def decrement(self, button: Gtk.Button | None = None) -> None:
|
||||
"""Decrease the volume by STEP_SIZE."""
|
||||
self._scale.set_value(self._scale.get_value() - STEP_SIZE)
|
||||
|
||||
def increment(self, button: Gtk.Button | None = None) -> None:
|
||||
"""Increase the volume by STEP_SIZE."""
|
||||
self._scale.set_value(self._scale.get_value() + STEP_SIZE)
|
||||
|
||||
def __value_changed(self, range: Gtk.Range) -> None:
|
||||
self.volume = range.get_value()
|
||||
|
||||
|
||||
class BackgroundRow(Adw.ExpanderRow):
|
||||
"""A VolumeRow for setting Background Listening volume."""
|
||||
|
||||
enabled = GObject.Property(type=bool, default=False)
|
||||
volume = GObject.Property(type=float, default=0.5)
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize the BackgroundRow."""
|
||||
super().__init__(title="Background Listening",
|
||||
subtitle="Decrease the volume to help focus")
|
||||
self._switch = Gtk.Switch(valign=Gtk.Align.CENTER)
|
||||
self._volume = VolumeRow(volume=self.volume)
|
||||
|
||||
self.add_prefix(self._switch)
|
||||
self.add_row(self._volume)
|
||||
|
||||
self._switch.bind_property("active", self, "expanded",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
self.bind_property("enabled", self._switch, "active",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
self.bind_property("volume", self._volume, "volume",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
|
@ -0,0 +1,61 @@
|
|||
# Copyright 2023 (c) Anna Schumaker.
|
||||
"""Our adaptable layout that can rearrange widgets as the window is resized."""
|
||||
from gi.repository import GObject
|
||||
from gi.repository import Gtk
|
||||
from gi.repository import Adw
|
||||
|
||||
|
||||
MIN_WIDTH = Adw.BreakpointConditionLengthType.MIN_WIDTH
|
||||
|
||||
|
||||
class Layout(Adw.Bin):
|
||||
"""A widget that can rearrange based on window dimensions."""
|
||||
|
||||
show_sidebar = GObject.Property(type=bool, default=False)
|
||||
|
||||
wide_view = GObject.Property(type=bool, default=False)
|
||||
|
||||
def __init__(self, *, content: Gtk.Widget = None,
|
||||
sidebar: Gtk.Widget = None):
|
||||
"""Initialize our Layout widget."""
|
||||
super().__init__()
|
||||
self._split_view = Adw.OverlaySplitView(content=content,
|
||||
sidebar=sidebar,
|
||||
collapsed=not self.wide_view)
|
||||
self.props.child = self._split_view
|
||||
|
||||
self.bind_property("show-sidebar", self._split_view, "show-sidebar",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
self.bind_property("wide-view", self._split_view, "collapsed",
|
||||
GObject.BindingFlags.INVERT_BOOLEAN)
|
||||
|
||||
def __define_breakpoint(self, property: str, value: bool,
|
||||
length: int) -> Adw.Breakpoint:
|
||||
condition = Adw.BreakpointCondition.new_length(MIN_WIDTH, length,
|
||||
Adw.LengthUnit.SP)
|
||||
breakpoint = Adw.Breakpoint.new(condition)
|
||||
breakpoint.add_setter(self, property, GObject.Value(bool, value))
|
||||
return breakpoint
|
||||
|
||||
@GObject.Property(type=Gtk.Widget)
|
||||
def content(self) -> Gtk.Widget:
|
||||
"""Get the content widget for the Layout."""
|
||||
return self._split_view.props.content
|
||||
|
||||
@content.setter
|
||||
def content(self, widget: Gtk.Widget) -> None:
|
||||
self._split_view.props.content = widget
|
||||
|
||||
@GObject.Property(type=Gtk.Widget)
|
||||
def sidebar(self) -> Gtk.Widget:
|
||||
"""Get the sidebar widget for the Layout."""
|
||||
return self._split_view.props.sidebar
|
||||
|
||||
@sidebar.setter
|
||||
def sidebar(self, widget: Gtk.Widget) -> None:
|
||||
self._split_view.props.sidebar = widget
|
||||
|
||||
@property
|
||||
def breakpoints(self) -> list[Adw.Breakpoint]:
|
||||
"""Get a list of breakpoints supported by the layout."""
|
||||
return [self.__define_breakpoint("wide-view", True, 1000)]
|
|
@ -0,0 +1,114 @@
|
|||
# Copyright 2024 (c) Anna Schumaker.
|
||||
"""Our ListenBrainz custom GObject."""
|
||||
from gi.repository import GObject
|
||||
from gi.repository import GLib
|
||||
from .. import db
|
||||
from . import listen
|
||||
from . import thread
|
||||
from . import task
|
||||
|
||||
|
||||
class ListenBrainz(GObject.GObject):
|
||||
"""Our main ListenBrainz GObject."""
|
||||
|
||||
sql = GObject.Property(type=db.Connection)
|
||||
offline = GObject.Property(type=bool, default=True)
|
||||
user_token = GObject.Property(type=str)
|
||||
valid_token = GObject.Property(type=bool, default=True)
|
||||
now_playing = GObject.Property(type=db.tracks.Track)
|
||||
|
||||
def __init__(self, sql: db.Connection):
|
||||
"""Initialize the ListenBrainz GObject."""
|
||||
super().__init__(sql=sql)
|
||||
self._queue = task.Queue()
|
||||
self._thread = thread.Thread()
|
||||
|
||||
self._idle_id = None
|
||||
self._timeout_id = None
|
||||
|
||||
self.connect("notify::offline", self.__notify_offline)
|
||||
self.connect("notify::user-token", self.__notify_user_token)
|
||||
self.connect("notify::now-playing", self.__notify_now_playing)
|
||||
|
||||
def __check_connected(self) -> bool:
|
||||
return len(self.user_token) and self.valid_token and not self.offline
|
||||
|
||||
def __check_online(self) -> None:
|
||||
self.notify("user-token")
|
||||
|
||||
def __check_result(self) -> None:
|
||||
if (res := self._thread.get_result()) is not None:
|
||||
self.valid_token = res.valid
|
||||
self.offline = res.offline
|
||||
if res.op == "submit-listens" and self.valid_token \
|
||||
and not self.offline:
|
||||
listens = [lsn.listenid for lsn in res.listens]
|
||||
self.sql.tracks.delete_listens(listens)
|
||||
|
||||
def __parse_task(self, op: str, *args) -> bool:
|
||||
match op:
|
||||
case "clear-token":
|
||||
self._thread.clear_user_token()
|
||||
case "now-playing":
|
||||
self._thread.submit_now_playing(listen.Listen(*args))
|
||||
case "set-token":
|
||||
self._thread.set_user_token(*args)
|
||||
case "submit-listens":
|
||||
listens = self.sql.tracks.get_n_listens(50)
|
||||
if len(listens) == 0:
|
||||
self._idle_id = None
|
||||
return GLib.SOURCE_REMOVE
|
||||
self._thread.submit_listens([listen.Listen(trk, listenid=id,
|
||||
listened_at=ts)
|
||||
for (id, trk, ts) in listens])
|
||||
return GLib.SOURCE_CONTINUE
|
||||
|
||||
def __idle_work(self) -> bool:
|
||||
if self.sql.loaded and self._thread.ready.is_set():
|
||||
self.__check_result()
|
||||
return self.__parse_task(*self._queue.pop())
|
||||
return GLib.SOURCE_CONTINUE
|
||||
|
||||
def __idle_start(self) -> None:
|
||||
if self._idle_id is None:
|
||||
self._idle_id = GLib.idle_add(self.__idle_work)
|
||||
|
||||
def __notify_offline(self, listenbrainz: GObject.GObject,
|
||||
param: GObject.ParamSpec) -> None:
|
||||
if self.offline and self._timeout_id is None:
|
||||
self._timeout_id = GLib.timeout_add_seconds(300,
|
||||
self.__check_online)
|
||||
elif not self.offline and self._timeout_id is not None:
|
||||
self.__source_stop("_timeout_id")
|
||||
|
||||
def __notify_user_token(self, listenbrainz: GObject.GObject,
|
||||
param: GObject.ParamSpec) -> None:
|
||||
match self.user_token:
|
||||
case "": self._queue.push("clear-token")
|
||||
case _: self._queue.push("set-token", self.user_token)
|
||||
self.__idle_start()
|
||||
|
||||
def __notify_now_playing(self, listenbrainz: GObject.GObject,
|
||||
param: GObject.ParamSpec) -> None:
|
||||
if self.now_playing is not None:
|
||||
self._queue.push("now-playing", self.now_playing)
|
||||
if self.__check_connected():
|
||||
self.__idle_start()
|
||||
else:
|
||||
self._queue.clear("now-playing")
|
||||
|
||||
def __source_stop(self, srcid: str) -> None:
|
||||
if (id := getattr(self, srcid)) is not None:
|
||||
GLib.source_remove(id)
|
||||
setattr(self, srcid, None)
|
||||
|
||||
def stop(self) -> None:
|
||||
"""Stop the ListenBrainz thread."""
|
||||
self.__source_stop("_idle_id")
|
||||
self.__source_stop("_timeout_id")
|
||||
self._thread.stop()
|
||||
|
||||
def submit_listens(self, *args) -> None:
|
||||
"""Submit recent listens to ListenBrainz."""
|
||||
if self.__check_connected():
|
||||
self.__idle_start()
|
|
@ -0,0 +1,28 @@
|
|||
# Copyright 2024 (c) Anna Schumaker.
|
||||
"""Convert a db.track.Track to a liblistenbrainz.Listen."""
|
||||
import datetime
|
||||
import dateutil.tz
|
||||
import liblistenbrainz
|
||||
from .. import db
|
||||
from .. import gsetup
|
||||
|
||||
|
||||
class Listen(liblistenbrainz.Listen):
|
||||
"""A single ListenBrainz Listen."""
|
||||
|
||||
def __init__(self, track: db.tracks.Track, *, listenid: int = None,
|
||||
listened_at: datetime.datetime = None):
|
||||
"""Initialize our Listen class."""
|
||||
album = track.get_medium().get_album()
|
||||
artists = [a.mbid for a in track.get_artists() if len(a.mbid) > 0]
|
||||
album_mbid = album.mbid if len(album.mbid) > 0 else None
|
||||
super().__init__(track.title, track.artist, release_name=album.name,
|
||||
artist_mbids=artists, release_group_mbid=album_mbid,
|
||||
tracknumber=track.number,
|
||||
additional_info={"media_player":
|
||||
f"emmental{gsetup.DEBUG_STR}"})
|
||||
self.listenid = listenid
|
||||
|
||||
if listened_at is not None:
|
||||
when = listened_at.replace(tzinfo=dateutil.tz.tzutc())
|
||||
self.listened_at = when.astimezone().timestamp()
|
|
@ -0,0 +1,31 @@
|
|||
# Copyright 2024 (c) Anna Schumaker.
|
||||
"""Our ListenBrainz operation priority queue."""
|
||||
|
||||
|
||||
class Queue:
|
||||
"""A queue for prioritizing ListenBrainz operations."""
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize the task Queue."""
|
||||
self._set_token = None
|
||||
self._now_playing = None
|
||||
|
||||
def clear(self, op: str) -> None:
|
||||
"""Clear a pending operation."""
|
||||
match op:
|
||||
case "clear-token" | "set-token": self._set_token = None
|
||||
case "now-playing": self._now_playing = None
|
||||
|
||||
def push(self, op: str, *args) -> None:
|
||||
"""Push an operation onto the queue."""
|
||||
match op:
|
||||
case "clear-token" | "set-token": self._set_token = (op, *args)
|
||||
case "now-playing": self._now_playing = (op, *args)
|
||||
|
||||
def pop(self) -> tuple:
|
||||
"""Pop an operation off the queue."""
|
||||
if (res := self._set_token) is not None:
|
||||
self._set_token = None
|
||||
elif (res := self._now_playing) is not None:
|
||||
self._now_playing = None
|
||||
return res if res is not None else ("submit-listens",)
|
|
@ -0,0 +1,96 @@
|
|||
# Copyright 2024 (c) Anna Schumaker.
|
||||
"""Our ListenBrainz client thread."""
|
||||
import liblistenbrainz
|
||||
import requests
|
||||
from .. import thread
|
||||
|
||||
|
||||
class Thread(thread.Thread):
|
||||
"""Thread for submitting listens to ListenBrainz."""
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize the ListenBrainz Thread object."""
|
||||
super().__init__()
|
||||
self._client = liblistenbrainz.client.ListenBrainz()
|
||||
|
||||
def __print(self, text: str) -> None:
|
||||
print(f"listenbrainz: {text}")
|
||||
|
||||
def __set_user_token(self, token: str) -> None:
|
||||
try:
|
||||
self._client.set_auth_token(token)
|
||||
self.set_result("set-token", token=token)
|
||||
except liblistenbrainz.errors.InvalidAuthTokenException:
|
||||
self.set_result("set-token", token=token, valid=False)
|
||||
except requests.exceptions.ConnectionError:
|
||||
self.set_result("set-token", token=token, offline=True)
|
||||
|
||||
def __submit_now_playing(self, listen: liblistenbrainz.Listen) -> None:
|
||||
try:
|
||||
self._client.submit_playing_now(listen)
|
||||
self.set_result("now-playing")
|
||||
except liblistenbrainz.errors.ListenBrainzAPIException:
|
||||
self.set_result("now-playing", valid=False)
|
||||
except requests.exceptions.ConnectionError:
|
||||
self.set_result("now-playing", offline=True)
|
||||
|
||||
def __submit_listens(self, listens: list[liblistenbrainz.Listen]) -> None:
|
||||
try:
|
||||
if len(listens) == 1:
|
||||
self._client.submit_single_listen(listens[0])
|
||||
else:
|
||||
self._client.submit_multiple_listens(listens)
|
||||
self.set_result("submit-listens", listens=listens)
|
||||
except liblistenbrainz.errors.ListenBrainzAPIException:
|
||||
self.set_result("submit-listens", listens=listens, valid=False)
|
||||
except requests.exceptions.ConnectionError:
|
||||
self.set_result("submit-listens", listens=listens, offline=True)
|
||||
|
||||
def do_run_task(self, task: thread.Data) -> None:
|
||||
"""Call a specific listenbrainz operation."""
|
||||
match task.op:
|
||||
case "clear-token":
|
||||
self._client.set_auth_token(None, check_validity=False)
|
||||
self.set_result("clear-token")
|
||||
case "now-playing":
|
||||
self.__submit_now_playing(task.listen)
|
||||
case "set-token":
|
||||
self.__set_user_token(task.token)
|
||||
case "submit-listens":
|
||||
self.__submit_listens(task.listens)
|
||||
|
||||
def clear_user_token(self) -> None:
|
||||
"""Schedule clearing the user token."""
|
||||
self.__print("clearing user token")
|
||||
self.set_task(op="clear-token")
|
||||
|
||||
def get_result(self, **kwargs) -> thread.Data:
|
||||
"""Get the result of a listenbrainz task."""
|
||||
if (res := super().get_result(**kwargs)) is not None:
|
||||
if not res.valid:
|
||||
self.__print("user token is invalid")
|
||||
if res.offline:
|
||||
self.__print("offline")
|
||||
return res
|
||||
|
||||
def set_result(self, op: str, *, valid: bool = True,
|
||||
offline: bool = False, **kwargs) -> None:
|
||||
"""Set the Thread result with a standard format for all ops."""
|
||||
super().set_result(op=op, valid=valid, offline=offline, **kwargs)
|
||||
|
||||
def set_user_token(self, token: str) -> None:
|
||||
"""Schedule setting the user token."""
|
||||
self.__print("setting user token")
|
||||
self.set_task(op="set-token", token=token)
|
||||
|
||||
def submit_now_playing(self, listen: liblistenbrainz.Listen) -> None:
|
||||
"""Schedule setting the now-playing track."""
|
||||
self.__print(f"now playing '{listen.track_name}' " +
|
||||
f"by '{listen.artist_name}'")
|
||||
self.set_task(op="now-playing", listen=listen)
|
||||
|
||||
def submit_listens(self, listens: list[liblistenbrainz.Listen]) -> None:
|
||||
"""Submit listens to listenbrainz."""
|
||||
num = len(listens)
|
||||
self.__print(f"submitting {num} listen{'s' if num != 1 else ''}")
|
||||
self.set_task(op="submit-listens", listens=listens)
|
|
@ -0,0 +1,53 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""Implement the MPRIS2 Specification."""
|
||||
from gi.repository import GObject
|
||||
from gi.repository import Gio
|
||||
from .. import gsetup
|
||||
from . import application
|
||||
from . import player
|
||||
|
||||
MPRIS2_ID = f"org.mpris.MediaPlayer2.emmental{gsetup.DEBUG_STR}"
|
||||
|
||||
|
||||
class Connection(GObject.GObject):
|
||||
"""Our Mpris2 Object."""
|
||||
|
||||
dbus = GObject.Property(type=Gio.DBusConnection)
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize Mpris2."""
|
||||
super().__init__()
|
||||
self.app = application.Application()
|
||||
self.player = player.Player()
|
||||
|
||||
self.bind_property("dbus", self.app, "dbus")
|
||||
self.bind_property("dbus", self.player, "dbus")
|
||||
|
||||
self._busid = Gio.bus_own_name(Gio.BusType.SESSION, MPRIS2_ID,
|
||||
Gio.BusNameOwnerFlags.NONE,
|
||||
self.__on_bus_acquired, None,
|
||||
self.__on_name_lost)
|
||||
|
||||
def __del__(self):
|
||||
"""Clean up."""
|
||||
self.disconnect()
|
||||
|
||||
def __on_bus_acquired(self, dbus: Gio.DBusConnection, name: str) -> None:
|
||||
self.dbus = dbus
|
||||
self.app.register(dbus)
|
||||
self.player.register(dbus)
|
||||
|
||||
def __on_name_lost(self, dbus: Gio.DBusConnection, name: str) -> None:
|
||||
self.app.unregister(dbus)
|
||||
self.player.unregister(dbus)
|
||||
|
||||
def disconnect(self):
|
||||
"""Disconnect from dbus."""
|
||||
if self.dbus:
|
||||
self.app.unregister(self.dbus)
|
||||
self.player.unregister(self.dbus)
|
||||
self.dbus = None
|
||||
|
||||
if self._busid:
|
||||
Gio.bus_unown_name(self._busid)
|
||||
self._busid = None
|
|
@ -0,0 +1,49 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""Our Mpris2 Application dbus Object."""
|
||||
import pathlib
|
||||
from gi.repository import GObject
|
||||
from gi.repository import GLib
|
||||
from . import dbus
|
||||
|
||||
MPRIS2_XML = pathlib.Path(__file__).parent / "MediaPlayer2.xml"
|
||||
|
||||
|
||||
class Application(dbus.Object):
|
||||
"""The mpris2 Application dbus object."""
|
||||
|
||||
CanQuit = GObject.Property(type=bool, default=True)
|
||||
Fullscreen = GObject.Property(type=bool, default=False)
|
||||
CanSetFullscreen = GObject.Property(type=bool, default=True)
|
||||
CanRaise = GObject.Property(type=bool, default=True)
|
||||
HasTrackList = GObject.Property(type=bool, default=False)
|
||||
Identity = GObject.Property(type=str, default="Emmental Music Player")
|
||||
DesktopEntry = GObject.Property(type=str, default="emmental")
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize the mpris2 application object."""
|
||||
super().__init__(xml=MPRIS2_XML)
|
||||
|
||||
def do_notify(self, property: str) -> None:
|
||||
"""Notify DBus when the Fullscreen property changes."""
|
||||
match property:
|
||||
case "Fullscreen":
|
||||
value = GLib.Variant("b", self.Fullscreen)
|
||||
self.properties_changed({property: value})
|
||||
|
||||
@GObject.Property
|
||||
def SupportedUriSchemes(self) -> list[str]:
|
||||
"""URI schemes supported by Emmental."""
|
||||
return ["file"]
|
||||
|
||||
@GObject.Property
|
||||
def SupportedMimeTypes(self) -> list[str]:
|
||||
"""Mime Types supported by Emmental."""
|
||||
return ["audio"]
|
||||
|
||||
@GObject.Signal
|
||||
def Raise(self) -> None:
|
||||
"""Raise the window."""
|
||||
|
||||
@GObject.Signal
|
||||
def Quit(self) -> None:
|
||||
"""Quit Emmental."""
|
|
@ -0,0 +1,89 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""Our generic dbus object."""
|
||||
import pathlib
|
||||
from gi.repository import GObject
|
||||
from gi.repository import GLib
|
||||
from gi.repository import Gio
|
||||
|
||||
OBJECT_PATH = "/org/mpris/MediaPlayer2"
|
||||
|
||||
|
||||
class Object(GObject.GObject):
|
||||
"""A generic dbus object."""
|
||||
|
||||
dbus = GObject.Property(type=Gio.DBusConnection)
|
||||
nodeinfo = GObject.Property(type=Gio.DBusNodeInfo)
|
||||
interface = GObject.Property(type=Gio.DBusInterfaceInfo)
|
||||
registration = GObject.Property(type=int)
|
||||
|
||||
def __init__(self, xml: pathlib.Path = None):
|
||||
"""Initialize a dbus Object."""
|
||||
super().__init__()
|
||||
if xml and xml.is_file():
|
||||
with open(xml, 'r') as f:
|
||||
self.nodeinfo = Gio.DBusNodeInfo.new_for_xml(f.read())
|
||||
self.interface = self.nodeinfo.interfaces[0]
|
||||
self.connect("notify", self.__on_notify)
|
||||
|
||||
def __on_notify(self, object: GObject.GObject, param) -> None:
|
||||
self.do_notify(param.name)
|
||||
|
||||
def do_notify(self, property: str) -> None:
|
||||
"""Handle a property value changing."""
|
||||
|
||||
def link_property(self, property: str, object: GObject.GObject,
|
||||
object_property: str) -> None:
|
||||
"""Link a dbus property to the object."""
|
||||
self.bind_property(property, object, object_property,
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
|
||||
def properties_changed(self, changed: dict) -> None:
|
||||
"""Emit the org.freedesktop.DBus.PropertiesChanged signal."""
|
||||
if self.dbus is None:
|
||||
return
|
||||
|
||||
args = GLib.Variant.new_tuple(GLib.Variant("s", self.interface.name),
|
||||
GLib.Variant("a{sv}", changed),
|
||||
GLib.Variant("as", []))
|
||||
self.dbus.emit_signal(None, OBJECT_PATH,
|
||||
"org.freedesktop.DBus.Properties",
|
||||
"PropertiesChanged", args)
|
||||
|
||||
def register(self, dbus: Gio.DBusConnection):
|
||||
"""Register this dbus Object."""
|
||||
self.registration = dbus.register_object(OBJECT_PATH, self.interface,
|
||||
self.__method_call,
|
||||
self.__get_property,
|
||||
self.__set_property)
|
||||
|
||||
def unregister(self, dbus: Gio.DBusConnection):
|
||||
"""Unregister this Object from the bus."""
|
||||
dbus.unregister_object(self.registration)
|
||||
self.registration = 0
|
||||
|
||||
def __method_call(self, dbus: Gio.DBusConnection, sender: str, object: str,
|
||||
interface: str, method: str, parameters: GLib.Variant,
|
||||
invocation: Gio.DBusMethodInvocation) -> None:
|
||||
if object != OBJECT_PATH or interface != self.interface.name:
|
||||
return None
|
||||
|
||||
self.emit(method, *parameters.unpack())
|
||||
invocation.return_value(GLib.Variant.new_tuple())
|
||||
|
||||
def __get_property(self, dbus: Gio.DBusConnection, sender: str,
|
||||
object: str, interface: str,
|
||||
property: str) -> GLib.Variant | None:
|
||||
if object != OBJECT_PATH or interface != self.interface.name:
|
||||
return None
|
||||
|
||||
if property_info := self.interface.lookup_property(property):
|
||||
return GLib.Variant(property_info.signature,
|
||||
self.get_property(property))
|
||||
|
||||
def __set_property(self, dbus: Gio.DBusConnection, sender: str,
|
||||
object: str, interface: str, property: str,
|
||||
value: GLib.Variant) -> bool:
|
||||
if object != OBJECT_PATH or interface != self.interface.name:
|
||||
return None
|
||||
self.set_property(property, value.unpack())
|
||||
return True
|
|
@ -0,0 +1,136 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""Our Mpris2 Player dbus Object."""
|
||||
import pathlib
|
||||
from gi.repository import GObject
|
||||
from gi.repository import GLib
|
||||
from .. import path
|
||||
from . import dbus
|
||||
|
||||
PLAYER_XML = pathlib.Path(__file__).parent / "Player.xml"
|
||||
OBJECT_PATH = "/com/nowheycreamery/emmental"
|
||||
|
||||
|
||||
class Player(dbus.Object):
|
||||
"""The mpris2 Player dbus object."""
|
||||
|
||||
PlaybackStatus = GObject.Property(type=str, default="Stopped")
|
||||
LoopStatus = GObject.Property(type=str, default="None")
|
||||
Rate = GObject.Property(type=float, default=1.0)
|
||||
Shuffle = GObject.Property(type=bool, default=False)
|
||||
Volume = GObject.Property(type=float, default=1.0)
|
||||
Position = GObject.Property(type=float, default=0)
|
||||
MinimumRate = GObject.Property(type=float, default=1.0)
|
||||
MaximumRate = GObject.Property(type=float, default=1.0)
|
||||
CanGoNext = GObject.Property(type=bool, default=False)
|
||||
CanGoPrevious = GObject.Property(type=bool, default=False)
|
||||
CanPlay = GObject.Property(type=bool, default=False)
|
||||
CanPause = GObject.Property(type=bool, default=False)
|
||||
CanSeek = GObject.Property(type=bool, default=False)
|
||||
CanControl = GObject.Property(type=bool, default=True)
|
||||
|
||||
artist = GObject.Property(type=str)
|
||||
album = GObject.Property(type=str)
|
||||
album_artist = GObject.Property(type=str)
|
||||
album_disc_number = GObject.Property(type=int)
|
||||
title = GObject.Property(type=str)
|
||||
track_number = GObject.Property(type=int)
|
||||
duration = GObject.Property(type=float)
|
||||
trackid = GObject.Property(type=int)
|
||||
|
||||
file = GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
artwork = GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize the mpris2 application object."""
|
||||
super().__init__(xml=PLAYER_XML)
|
||||
|
||||
def do_notify(self, property: str) -> None:
|
||||
"""Notify DBus when tags change."""
|
||||
match property:
|
||||
case "artist" | "album" | "album-artist" | "album-disc-number" | \
|
||||
"title" | "track-number" | "duration" | "trackid" | \
|
||||
"uri" | "artwork":
|
||||
changed = GLib.Variant("a{sv}", self.Metadata)
|
||||
self.properties_changed({"Metadata": changed})
|
||||
case "PlaybackStatus":
|
||||
changed = GLib.Variant("s", self.PlaybackStatus)
|
||||
self.properties_changed({property: changed})
|
||||
case "CanPlay" | "CanPause" | "CanSeek":
|
||||
changed = GLib.Variant("b", self.get_property(property))
|
||||
self.properties_changed({property: changed})
|
||||
|
||||
def seeked(self, newpos: float) -> None:
|
||||
"""Notify that the track position has changed."""
|
||||
args = GLib.Variant.new_tuple(GLib.Variant("x", newpos))
|
||||
self.dbus.emit_signal(None, dbus.OBJECT_PATH, self.interface.name,
|
||||
"Seeked", args)
|
||||
|
||||
@GObject.Property
|
||||
def Metadata(self) -> dict:
|
||||
"""Metadata for the current Track."""
|
||||
res = dict()
|
||||
if self.file:
|
||||
trackid = f"{OBJECT_PATH}/{self.trackid}"
|
||||
res["mpris:trackid"] = GLib.Variant("o", trackid)
|
||||
res["mpris:length"] = GLib.Variant("x", self.duration)
|
||||
res["xesam:url"] = GLib.Variant("s", self.file.as_uri())
|
||||
|
||||
if self.artwork is not None:
|
||||
res["mpris:artUrl"] = GLib.Variant("s", self.artwork.as_uri())
|
||||
if len(self.artist) > 0:
|
||||
res["xesam:artist"] = GLib.Variant("as", [self.artist])
|
||||
if len(self.album) > 0:
|
||||
res["xesam:album"] = GLib.Variant("s", self.album)
|
||||
if len(self.album_artist) > 0:
|
||||
res["xesam:albumArtist"] = GLib.Variant("as",
|
||||
[self.album_artist])
|
||||
if self.album_disc_number > 0:
|
||||
res["xesam:discNumber"] = GLib.Variant("u",
|
||||
self.album_disc_number)
|
||||
if len(self.title) > 0:
|
||||
res["xesam:title"] = GLib.Variant("s", self.title)
|
||||
if self.track_number > 0:
|
||||
res["xesam:trackNumber"] = GLib.Variant("u", self.track_number)
|
||||
|
||||
return res
|
||||
|
||||
@GObject.Signal
|
||||
def Next(self) -> None:
|
||||
"""Skip to the next track."""
|
||||
|
||||
@GObject.Signal
|
||||
def Previous(self) -> None:
|
||||
"""Skip to the previous track."""
|
||||
|
||||
@GObject.Signal
|
||||
def Pause(self) -> None:
|
||||
"""Pause playback."""
|
||||
|
||||
@GObject.Signal
|
||||
def PlayPause(self) -> None:
|
||||
"""Toggle playback status."""
|
||||
|
||||
@GObject.Signal
|
||||
def Stop(self) -> None:
|
||||
"""Stop playback."""
|
||||
|
||||
@GObject.Signal
|
||||
def Play(self) -> None:
|
||||
"""Start or resume playback."""
|
||||
|
||||
@GObject.Signal(arg_types=(float,))
|
||||
def Seek(self, offset: float) -> None:
|
||||
"""Seek forward or backward by the given offset."""
|
||||
|
||||
@GObject.Signal(arg_types=(str, float))
|
||||
def SetPosition(self, trackid: str, position: float) -> None:
|
||||
"""Set the current track position in microseconds."""
|
||||
|
||||
@GObject.Signal(arg_types=(str,))
|
||||
def OpenUri(self, uri: str) -> None:
|
||||
"""Open the given uri."""
|
||||
self.emit("OpenPath", path.from_uri(uri))
|
||||
|
||||
@GObject.Signal(arg_types=(GObject.TYPE_PYOBJECT,))
|
||||
def OpenPath(self, filepath: pathlib.Path) -> None:
|
||||
"""Open the given path."""
|
|
@ -0,0 +1,144 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""A card for displaying information about the currently playing track."""
|
||||
from gi.repository import GObject
|
||||
from gi.repository import Gtk
|
||||
from ..action import ActionEntry
|
||||
from .. import buttons
|
||||
from . import artwork
|
||||
from . import controls
|
||||
from . import seeker
|
||||
from . import tags
|
||||
|
||||
|
||||
class Card(Gtk.Box):
|
||||
"""The Now Playing information card."""
|
||||
|
||||
artwork = GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
title = GObject.Property(type=str)
|
||||
album = GObject.Property(type=str)
|
||||
artist = GObject.Property(type=str)
|
||||
album_artist = GObject.Property(type=str)
|
||||
favorite = GObject.Property(type=bool, default=False)
|
||||
duration = GObject.Property(type=float, default=1)
|
||||
position = GObject.Property(type=float, default=0)
|
||||
prefer_artist = GObject.Property(type=bool, default=True)
|
||||
playing = GObject.Property(type=bool, default=False)
|
||||
autopause = GObject.Property(type=int, default=-1, minimum=-1, maximum=99)
|
||||
|
||||
have_next = GObject.Property(type=bool, default=False)
|
||||
have_previous = GObject.Property(type=bool, default=False)
|
||||
have_track = GObject.Property(type=bool, default=False)
|
||||
have_db_track = GObject.Property(type=bool, default=False)
|
||||
editing = GObject.Property(type=bool, default=False)
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize a Now Playing Card."""
|
||||
super().__init__()
|
||||
self._grid = Gtk.Grid()
|
||||
self._artwork = artwork.Artwork()
|
||||
self._tags = tags.TagInfo()
|
||||
self._controls = controls.Controls()
|
||||
self._bottom_box = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 0)
|
||||
self._favorite = buttons.ImageToggle("heart-filled",
|
||||
"heart-outline-thick-symbolic",
|
||||
"remove from 'Favorite Tracks'",
|
||||
"add to 'Favorite Tracks'",
|
||||
large_icon=True,
|
||||
has_frame=False, sensitive=False,
|
||||
valign=Gtk.Align.CENTER)
|
||||
self._jump = buttons.Button(icon_name="arrow4-down-symbolic",
|
||||
tooltip_text="scroll to current track",
|
||||
large_icon=True, sensitive=False,
|
||||
has_frame=False, valign=Gtk.Align.CENTER)
|
||||
self._seeker = seeker.Scale(sensitive=False)
|
||||
|
||||
self.bind_property("artwork", self._artwork, "filepath")
|
||||
for prop in ["title", "album", "artist", "album-artist"]:
|
||||
self.bind_property(prop, self._tags, prop)
|
||||
self.bind_property("prefer-artist", self._tags, "prefer-artist",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
for prop in ["playing", "editing", "have-next",
|
||||
"have-previous", "have-track"]:
|
||||
self.bind_property(prop, self._controls, prop)
|
||||
self.bind_property("have-db-track", self._jump, "sensitive")
|
||||
self.bind_property("have-db-track", self._favorite, "sensitive")
|
||||
self.bind_property("have-track", self._seeker, "sensitive")
|
||||
self.bind_property("autopause", self._controls, "autopause",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
self.bind_property("favorite", self._favorite, "active",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
self.bind_property("duration", self._seeker, "duration")
|
||||
self.bind_property("position", self._seeker, "position")
|
||||
|
||||
for sig in ["play", "pause", "previous", "next"]:
|
||||
self._controls.connect(sig, self.__on_control, sig)
|
||||
self._jump.connect("clicked", self.__on_jump)
|
||||
self._seeker.connect("change-value", self.__on_seek)
|
||||
|
||||
self._bottom_box.append(self._favorite)
|
||||
self._bottom_box.append(self._jump)
|
||||
self._bottom_box.append(self._seeker)
|
||||
self._grid.attach(self._tags, 0, 0, 1, 1)
|
||||
self._grid.attach(self._controls, 1, 0, 1, 1)
|
||||
self._grid.attach(self._bottom_box, 0, 1, 2, 1)
|
||||
|
||||
self.append(self._artwork)
|
||||
self.append(self._grid)
|
||||
self.add_css_class("card")
|
||||
|
||||
def __on_control(self, controls: controls.Controls, signal: str) -> None:
|
||||
self.emit(signal)
|
||||
|
||||
def __on_jump(self, jump: Gtk.Button) -> None:
|
||||
self.emit("jump")
|
||||
|
||||
def __on_seek(self, seek: seeker.Scale, scroll: Gtk.ScrollType,
|
||||
value: float) -> None:
|
||||
self.emit("seek", value)
|
||||
|
||||
@property
|
||||
def accelerators(self) -> list[ActionEntry]:
|
||||
"""Get a list of accelerators for the Now Playing card."""
|
||||
return [ActionEntry("toggle-favorite", self._favorite.activate,
|
||||
"<Control>f", enabled=(self, "have-db-track")),
|
||||
ActionEntry("goto-current-track", self._jump.activate,
|
||||
"<Control>g", enabled=(self, "have-db-track")),
|
||||
ActionEntry("next-track", self._controls.activate_next,
|
||||
"Return", enabled=(self._controls,
|
||||
"can-activate-next")),
|
||||
ActionEntry("previous-track", self._controls.activate_previous,
|
||||
"BackSpace", enabled=(self._controls,
|
||||
"can-activate-prev")),
|
||||
ActionEntry("play-pause", self._controls.activate_play_pause,
|
||||
"space", enabled=(self._controls,
|
||||
"can-activate-play-pause")),
|
||||
ActionEntry("inc-autopause", self._controls.increase_autopause,
|
||||
"<Control>plus", "<Control>KP_Add",
|
||||
enabled=(self, "playing")),
|
||||
ActionEntry("dec-autopause", self._controls.decrease_autopause,
|
||||
"<Control>minus", "<Control>KP_Subtract",
|
||||
enabled=(self, "playing"))]
|
||||
|
||||
@GObject.Signal
|
||||
def jump(self) -> None:
|
||||
"""Signal that the Tracklist should be scrolled."""
|
||||
|
||||
@GObject.Signal
|
||||
def play(self) -> None:
|
||||
"""Signal that the Play button has been clicked."""
|
||||
|
||||
@GObject.Signal
|
||||
def pause(self) -> None:
|
||||
"""Signal that the Pause button has been clicked."""
|
||||
|
||||
@GObject.Signal
|
||||
def previous(self) -> None:
|
||||
"""Signal that the Previous button has been clicked."""
|
||||
|
||||
@GObject.Signal
|
||||
def next(self) -> None:
|
||||
"""Signal that the Nause button has been clicked."""
|
||||
|
||||
@GObject.Signal(arg_types=(float,))
|
||||
def seek(self, newpos: float) -> None:
|
||||
"""Signal that the user wants us to seek."""
|
|
@ -0,0 +1,50 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""Our custom Album Art widget."""
|
||||
import pathlib
|
||||
from gi.repository import GObject
|
||||
from gi.repository import Gtk
|
||||
from .. import gsetup
|
||||
|
||||
FALLBACK_RESOURCE = f"{gsetup.RESOURCE_ICONS}/emmental.svg"
|
||||
|
||||
|
||||
class Artwork(Gtk.Picture):
|
||||
"""Our custom Album Art widget takes a pathlib.Path."""
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize the Album Art widget."""
|
||||
super().__init__(content_fit=Gtk.ContentFit.CONTAIN,
|
||||
margin_top=6, margin_bottom=6,
|
||||
margin_start=6, margin_end=6,
|
||||
halign=Gtk.Align.CENTER, valign=Gtk.Align.CENTER)
|
||||
self._fullsize = Gtk.Picture(content_fit=Gtk.ContentFit.FILL)
|
||||
|
||||
self._popover = Gtk.Popover(child=self._fullsize)
|
||||
self._popover.set_parent(self)
|
||||
|
||||
self._clicked = Gtk.GestureClick()
|
||||
self._clicked.connect("released", self.clicked)
|
||||
self.add_controller(self._clicked)
|
||||
|
||||
self.add_css_class("card")
|
||||
self.filepath = None
|
||||
|
||||
@GObject.Property(type=GObject.TYPE_PYOBJECT)
|
||||
def filepath(self) -> pathlib.Path:
|
||||
"""Get the current artwork path."""
|
||||
name = self.get_file().get_parse_name()
|
||||
return None if name.startswith("resource:") else pathlib.Path(name)
|
||||
|
||||
@filepath.setter
|
||||
def filepath(self, path: pathlib.Path) -> None:
|
||||
if path is not None:
|
||||
self.set_filename(str(path))
|
||||
self._fullsize.set_filename(str(path))
|
||||
else:
|
||||
self.set_resource(FALLBACK_RESOURCE)
|
||||
self._fullsize.set_resource(FALLBACK_RESOURCE)
|
||||
|
||||
def clicked(self, gesture: Gtk.GestureClick, n_press: int,
|
||||
x: float, y: float) -> None:
|
||||
"""Handle a click event."""
|
||||
self._popover.popup()
|
|
@ -0,0 +1,136 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""Widgets for configuring autopause."""
|
||||
import re
|
||||
from gi.repository import GObject
|
||||
from gi.repository import GLib
|
||||
from gi.repository import Gtk
|
||||
from .. import buttons
|
||||
|
||||
|
||||
class Entry(Gtk.Entry):
|
||||
"""A custom SpinButton so we can format output in Python."""
|
||||
|
||||
value = GObject.Property(type=int, default=-1, minimum=-1, maximum=99)
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize a Spin button."""
|
||||
super().__init__(max_width_chars=20, placeholder_text="Keep playing",
|
||||
primary_icon_sensitive=False,
|
||||
primary_icon_name="list-remove-symbolic",
|
||||
secondary_icon_name="list-add-symbolic")
|
||||
self._timeout = (None, None)
|
||||
#
|
||||
self.connect("activate", self.__parse_text)
|
||||
self.connect("icon_press", self.__icon_press)
|
||||
self.connect("icon_release", self.__icon_release)
|
||||
self.connect("notify::value", self.__update_text)
|
||||
|
||||
self.add_css_class("card")
|
||||
|
||||
def __set_value(self, newval: int) -> bool:
|
||||
if -1 <= newval <= 99:
|
||||
self.value = newval
|
||||
return True
|
||||
return False
|
||||
|
||||
def __parse_text(self, entry: Gtk.Entry) -> None:
|
||||
if parse := re.search(r"this|next|cancel|-?\d+",
|
||||
entry.get_text(), re.I):
|
||||
match parse.group().lower():
|
||||
case "cancel": self.__set_value(-1)
|
||||
case "this": self.__set_value(0)
|
||||
case "next": self.__set_value(1)
|
||||
case _: self.__set_value(int(parse.group()))
|
||||
self.delete_text(0, -1)
|
||||
|
||||
def __change_value(self, change_how: str) -> bool:
|
||||
match change_how:
|
||||
case "increment": status = self.__set_value(self.value + 1)
|
||||
case "decrement": status = self.__set_value(self.value - 1)
|
||||
|
||||
if not status:
|
||||
self._timeout = (None, None)
|
||||
elif self._timeout[1] == 150:
|
||||
return GLib.SOURCE_CONTINUE
|
||||
else:
|
||||
timeout_id = GLib.timeout_add(150, self.__change_value, change_how)
|
||||
self._timeout = (timeout_id, 150)
|
||||
return GLib.SOURCE_REMOVE
|
||||
|
||||
def __icon_press(self, entry: Gtk.Entry,
|
||||
icon_pos: Gtk.EntryIconPosition) -> None:
|
||||
self.__icon_release(entry, icon_pos)
|
||||
|
||||
match icon_pos:
|
||||
case Gtk.EntryIconPosition.SECONDARY:
|
||||
change_how = "increment"
|
||||
self.value += 1
|
||||
case Gtk.EntryIconPosition.PRIMARY:
|
||||
change_how = "decrement"
|
||||
self.value -= 1
|
||||
|
||||
timeout_id = GLib.timeout_add(500, self.__change_value, change_how)
|
||||
self._timeout = (timeout_id, 500)
|
||||
|
||||
def __icon_release(self, entry: Gtk.Entry,
|
||||
icon_pos: Gtk.EntryIconPosition) -> None:
|
||||
if self._timeout != (None, None):
|
||||
GLib.source_remove(self._timeout[0])
|
||||
self._timeout = (None, None)
|
||||
|
||||
def __update_text(self, spin, param) -> None:
|
||||
match self.value:
|
||||
case -1: text = "Keep playing"
|
||||
case 0: text = "Pause after this track"
|
||||
case 1: text = "Pause after the next track"
|
||||
case _: text = f"Pause after {self.value} tracks"
|
||||
|
||||
self.set_placeholder_text(text)
|
||||
self.set_icon_sensitive(Gtk.EntryIconPosition.PRIMARY,
|
||||
self.value > -1)
|
||||
self.set_icon_sensitive(Gtk.EntryIconPosition.SECONDARY,
|
||||
self.value < 99)
|
||||
|
||||
def decrement(self) -> None:
|
||||
"""Decrease the autopause count by 1."""
|
||||
if self.value > -1:
|
||||
self.value -= 1
|
||||
|
||||
def increment(self) -> None:
|
||||
"""Increase the autopause count by 1."""
|
||||
if self.value < 99:
|
||||
self.value += 1
|
||||
|
||||
|
||||
class Button(buttons.PopoverButton):
|
||||
"""A PopoverButton that displays Autopause count."""
|
||||
|
||||
value = GObject.Property(type=int, default=-1, minimum=-1, maximum=99)
|
||||
|
||||
def __init__(self, **kwargs):
|
||||
"""Initialize an Autopause Button."""
|
||||
super().__init__(popover_child=Entry(), **kwargs)
|
||||
self._arrow = Gtk.Image(icon_name="pan-down-symbolic", margin_top=6)
|
||||
self._count = Gtk.Label(yalign=0, halign=Gtk.Align.CENTER,
|
||||
margin_top=3)
|
||||
self._overlay = Gtk.Overlay(child=self._arrow)
|
||||
|
||||
self._overlay.add_overlay(self._count)
|
||||
self.bind_property("value", self.popover_child, "value",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
self.connect("notify::value", self.__notify_value)
|
||||
|
||||
self._count.set_markup("<small></small>")
|
||||
self.set_child(self._overlay)
|
||||
|
||||
def __notify_value(self, button: buttons.PopoverButton, param) -> None:
|
||||
text = str(self.value) if self.value > -1 else ""
|
||||
self._count.set_markup(f"<small>{text}</small>")
|
||||
|
||||
def decrement(self) -> None:
|
||||
"""Decrease the autopause value."""
|
||||
self.popover_child.decrement()
|
||||
|
||||
def increment(self) -> None:
|
||||
"""Increase the autopause value."""
|
||||
self.popover_child.increment()
|
|
@ -0,0 +1,140 @@
|
|||
# Copyright 2022 (c) Anna Schumaker.
|
||||
"""Our playback control widgets."""
|
||||
from gi.repository import GObject
|
||||
from gi.repository import Gtk
|
||||
from . import autopause
|
||||
from .. import buttons
|
||||
from .. import window
|
||||
|
||||
MARGIN = 24
|
||||
|
||||
|
||||
class PillButton(buttons.Button):
|
||||
"""A Button with the pill style class."""
|
||||
|
||||
def __init__(self, **kwargs):
|
||||
"""Initialize a Pill Button."""
|
||||
super().__init__(large_icon=True, **kwargs)
|
||||
self.add_css_class("pill")
|
||||
|
||||
|
||||
class Controls(Gtk.Box):
|
||||
"""Our playback control widgets."""
|
||||
|
||||
autopause = GObject.Property(type=int, default=-1, minimum=-1, maximum=99)
|
||||
playing = GObject.Property(type=bool, default=False)
|
||||
|
||||
have_next = GObject.Property(type=bool, default=False)
|
||||
have_previous = GObject.Property(type=bool, default=False)
|
||||
have_track = GObject.Property(type=bool, default=False)
|
||||
|
||||
editing = GObject.Property(type=bool, default=False)
|
||||
can_activate_next = GObject.Property(type=bool, default=False)
|
||||
can_activate_prev = GObject.Property(type=bool, default=False)
|
||||
can_activate_play_pause = GObject.Property(type=bool, default=False)
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize the Controls."""
|
||||
super().__init__(valign=Gtk.Align.START, homogeneous=True,
|
||||
halign=Gtk.Align.END, hexpand=False,
|
||||
margin_start=MARGIN/2, margin_end=MARGIN,
|
||||
margin_top=MARGIN, margin_bottom=MARGIN)
|
||||
|
||||
self._autopause = autopause.Button()
|
||||
self._prev = PillButton(icon_name="media-skip-backward",
|
||||
tooltip_text="previous track", sensitive=False)
|
||||
self._play = PillButton(icon_name="play-large", tooltip_text="play",
|
||||
sensitive=False)
|
||||
self._pause = buttons.SplitButton(icon_name="pause-large",
|
||||
large_icon=True,
|
||||
tooltip_text="pause",
|
||||
secondary=self._autopause,
|
||||
visible=False, sensitive=False)
|
||||
self._next = PillButton(icon_name="media-skip-forward",
|
||||
tooltip_text="next track", sensitive=False)
|
||||
|
||||
for button in [self._prev, self._play, self._pause, self._next]:
|
||||
self.append(button)
|
||||
|
||||
self._prev.connect("clicked", self.__on_click, "previous")
|
||||
self._play.connect("clicked", self.__on_click, "play")
|
||||
self._pause.connect("clicked", self.__on_click, "pause")
|
||||
self._next.connect("clicked", self.__on_click, "next")
|
||||
|
||||
self.bind_property("autopause", self._autopause, "value",
|
||||
GObject.BindingFlags.BIDIRECTIONAL)
|
||||
self.bind_property("playing", self._pause, "visible")
|
||||
self.bind_property("playing", self._play, "visible",
|
||||
GObject.BindingFlags.INVERT_BOOLEAN)
|
||||
self.bind_property("have-next", self._next, "sensitive")
|
||||
self.bind_property("have-previous", self._prev, "sensitive")
|
||||
self.bind_property("have-track", self._play, "sensitive")
|
||||
self.bind_property("have-track", self._pause, "sensitive")
|
||||
self.connect("notify", self.__notify)
|
||||
|
||||
self.add_css_class("linked")
|
||||
|
||||
def __on_click(self, button: Gtk.Button, signal: str) -> None:
|
||||
self.emit(signal)
|
||||
|
||||
def __notify_playing(self, controls: Gtk.Box, param) -> None:
|
||||
if not self.playing and self.autopause != -1:
|
||||
if win := self.get_ancestor(window.Window):
|
||||
win.post_toast("Autopause Cancelled")
|
||||
self.autopause = -1
|
||||
|
||||
def __notify(self, controls: Gtk.Box, param) -> None:
|
||||
match param.name:
|
||||
case "editing":
|
||||
allowed = not self.editing
|
||||
self.can_activate_next = self.have_next and allowed
|
||||
self.can_activate_prev = self.have_previous and allowed
|
||||
self.can_activate_play_pause = self.have_track and allowed
|
||||
case "playing": self.__notify_playing(controls, param)
|
||||
case "have-next":
|
||||
self.can_activate_next = self.have_next and not self.editing
|
||||
case "have-previous":
|
||||
can_activate = self.have_previous and not self.editing
|
||||
self.can_activate_prev = can_activate
|
||||
case "have-track":
|
||||
can_activate = self.have_track and not self.editing
|
||||
self.can_activate_play_pause = can_activate
|
||||
|
||||
def activate_next(self) -> None:
|
||||
"""Activate the Next button."""
|
||||
self._next.activate()
|
||||
|
||||
def activate_previous(self) -> None:
|
||||
"""Activate the Previous button."""
|
||||
self._prev.activate()
|
||||
|
||||
def activate_play_pause(self) -> None:
|
||||
"""Activate the Play or Pause button."""
|
||||
if self.playing:
|
||||
self._pause.activate()
|
||||
else:
|
||||
self._play.activate()
|
||||
|
||||
def decrease_autopause(self) -> None:
|
||||
"""Decrease the autopause count."""
|
||||
self._autopause.decrement()
|
||||
|
||||
def increase_autopause(self) -> None:
|
||||
"""Increase the autopause count."""
|
||||
self._autopause.increment()
|
||||
|
||||
@GObject.Signal
|
||||
def previous(self) -> None:
|
||||
"""Signals that the Previous button has been clicked."""
|
||||
|
||||
@GObject.Signal
|
||||
def play(self) -> None:
|
||||
"""Signals that the Play button has been clicked."""
|
||||
|
||||
@GObject.Signal
|
||||
def pause(self) -> None:
|
||||
"""Signals that the Pause button has been clicked."""
|
||||
|
||||
@GObject.Signal
|
||||
def next(self) -> None:
|
||||
"""Signals that the Next button has been clicked."""
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue