00dani/mpd-now-playable
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
mpd-now-playable/schemata/config-v1.json

85 lines
2 KiB
JSON
Raw Normal View History

Support a TOML configuration file The new config file currently only configures the same options that were already available through environment variables. However I have ideas for additional features that would be much nicer to support using a structured configuration format like TOML rather than environment variables, so config files exist now! The previous environment variables are still supported and will be used if you don't have a config file. I plan to keep supporting the MPD_HOST and MPD_PORT environment variables forever since they're shared with other MPD clients such as mpc, but I may eventually drop the environment variables specific to mpd-now-playable in a future release.
2024-06-22 04:19:39 -04:00
{
Significantly overhaul configuration management Everything now uses bog-standard Python dataclasses, with Pydantic providing validation and type conversion through separate classes using its type adapter feature. It's also possible to define your classes using Pydantic's own model type directly, making the type adapter unnecessary, but I didn't want to do things that way because no actual validation is needed when constructing a Song instance for example. Having Pydantic do its thing only on-demand was preferable. I tried a number of validation libraries before settling on Pydantic for this. It's not the fastest option out there (msgspec is I think), but it makes adding support for third-party types like yarl.URL really easy, it generates a nice clean JSON Schema which is easy enough to adjust to my requirements through its GenerateJsonSchema hooks, and raw speed isn't all that important anyway since this is a single-user desktop program that reads its configuration file once on startup. Also, MessagePack is now mandatory if you're caching to an external service. It just didn't make a whole lot sense to explicitly install mpd-now-playable's Redis or Memcached support and then use pickling with them. With all this fussing around done, I'm probably finally ready to actually use that configuration file to configure new features! Yay!
2024-06-30 10:10:17 -04:00
"$defs": {
Refactor Cocoa stuff into a 'receiver' The idea here is that there are other places that might want to know what's playing, besides MPNowPlayingInfoCenter. For example, to expose the now playing info to Übersicht efficiently, it needs to be available from a web browser, ideally using WebSockets. So there could be a receiver that runs a small WebSockets server and sends out now playing info to anyone who connects. Additionally, I hope to write receivers for MPRIS and for the System Media Transport Controls on Windows, making mpd-now-playable equally useful across all platforms. None of this is implemented yet, of course, but I hope to get the WebSockets receiver done pretty soon! I'm going to keep the default behaviour unchanged. Unless you explicitly configure different receivers in config.toml, mpd-now-playable will just behave as an MPNowPlayingInfoCenter integration as it's always done.
2024-07-08 22:52:49 -04:00
"CocoaReceiverConfig": {
"properties": {
"kind": {
"const": "cocoa",
"default": "cocoa",
"enum": [
"cocoa"
],
"title": "Kind",
"type": "string"
}
},
"title": "CocoaReceiverConfig",
"type": "object"
},
Significantly overhaul configuration management Everything now uses bog-standard Python dataclasses, with Pydantic providing validation and type conversion through separate classes using its type adapter feature. It's also possible to define your classes using Pydantic's own model type directly, making the type adapter unnecessary, but I didn't want to do things that way because no actual validation is needed when constructing a Song instance for example. Having Pydantic do its thing only on-demand was preferable. I tried a number of validation libraries before settling on Pydantic for this. It's not the fastest option out there (msgspec is I think), but it makes adding support for third-party types like yarl.URL really easy, it generates a nice clean JSON Schema which is easy enough to adjust to my requirements through its GenerateJsonSchema hooks, and raw speed isn't all that important anyway since this is a single-user desktop program that reads its configuration file once on startup. Also, MessagePack is now mandatory if you're caching to an external service. It just didn't make a whole lot sense to explicitly install mpd-now-playable's Redis or Memcached support and then use pickling with them. With all this fussing around done, I'm probably finally ready to actually use that configuration file to configure new features! Yay!
2024-06-30 10:10:17 -04:00
"MpdConfig": {
Support a TOML configuration file The new config file currently only configures the same options that were already available through environment variables. However I have ideas for additional features that would be much nicer to support using a structured configuration format like TOML rather than environment variables, so config files exist now! The previous environment variables are still supported and will be used if you don't have a config file. I plan to keep supporting the MPD_HOST and MPD_PORT environment variables forever since they're shared with other MPD clients such as mpc, but I may eventually drop the environment variables specific to mpd-now-playable in a future release.
2024-06-22 04:19:39 -04:00
"properties": {
"host": {
"default": "127.0.0.1",
Add field descriptions to the config schema :)
2024-06-22 06:12:23 -04:00
"description": "The hostname or IP address of your MPD server. If you're running MPD on your local machine, you don't need to configure this.",
Support a TOML configuration file The new config file currently only configures the same options that were already available through environment variables. However I have ideas for additional features that would be much nicer to support using a structured configuration format like TOML rather than environment variables, so config files exist now! The previous environment variables are still supported and will be used if you don't have a config file. I plan to keep supporting the MPD_HOST and MPD_PORT environment variables forever since they're shared with other MPD clients such as mpc, but I may eventually drop the environment variables specific to mpd-now-playable in a future release.
2024-06-22 04:19:39 -04:00
"format": "hostname",
Significantly overhaul configuration management Everything now uses bog-standard Python dataclasses, with Pydantic providing validation and type conversion through separate classes using its type adapter feature. It's also possible to define your classes using Pydantic's own model type directly, making the type adapter unnecessary, but I didn't want to do things that way because no actual validation is needed when constructing a Song instance for example. Having Pydantic do its thing only on-demand was preferable. I tried a number of validation libraries before settling on Pydantic for this. It's not the fastest option out there (msgspec is I think), but it makes adding support for third-party types like yarl.URL really easy, it generates a nice clean JSON Schema which is easy enough to adjust to my requirements through its GenerateJsonSchema hooks, and raw speed isn't all that important anyway since this is a single-user desktop program that reads its configuration file once on startup. Also, MessagePack is now mandatory if you're caching to an external service. It just didn't make a whole lot sense to explicitly install mpd-now-playable's Redis or Memcached support and then use pickling with them. With all this fussing around done, I'm probably finally ready to actually use that configuration file to configure new features! Yay!
2024-06-30 10:10:17 -04:00
"title": "Host",
Support a TOML configuration file The new config file currently only configures the same options that were already available through environment variables. However I have ideas for additional features that would be much nicer to support using a structured configuration format like TOML rather than environment variables, so config files exist now! The previous environment variables are still supported and will be used if you don't have a config file. I plan to keep supporting the MPD_HOST and MPD_PORT environment variables forever since they're shared with other MPD clients such as mpc, but I may eventually drop the environment variables specific to mpd-now-playable in a future release.
2024-06-22 04:19:39 -04:00
"type": "string"
},
"password": {
Add field descriptions to the config schema :)
2024-06-22 06:12:23 -04:00
"description": "The password required to connect to your MPD instance, if you need one.",
Significantly overhaul configuration management Everything now uses bog-standard Python dataclasses, with Pydantic providing validation and type conversion through separate classes using its type adapter feature. It's also possible to define your classes using Pydantic's own model type directly, making the type adapter unnecessary, but I didn't want to do things that way because no actual validation is needed when constructing a Song instance for example. Having Pydantic do its thing only on-demand was preferable. I tried a number of validation libraries before settling on Pydantic for this. It's not the fastest option out there (msgspec is I think), but it makes adding support for third-party types like yarl.URL really easy, it generates a nice clean JSON Schema which is easy enough to adjust to my requirements through its GenerateJsonSchema hooks, and raw speed isn't all that important anyway since this is a single-user desktop program that reads its configuration file once on startup. Also, MessagePack is now mandatory if you're caching to an external service. It just didn't make a whole lot sense to explicitly install mpd-now-playable's Redis or Memcached support and then use pickling with them. With all this fussing around done, I'm probably finally ready to actually use that configuration file to configure new features! Yay!
2024-06-30 10:10:17 -04:00
"format": "password",
"title": "Password",
"type": "string",
"writeOnly": true
Support a TOML configuration file The new config file currently only configures the same options that were already available through environment variables. However I have ideas for additional features that would be much nicer to support using a structured configuration format like TOML rather than environment variables, so config files exist now! The previous environment variables are still supported and will be used if you don't have a config file. I plan to keep supporting the MPD_HOST and MPD_PORT environment variables forever since they're shared with other MPD clients such as mpc, but I may eventually drop the environment variables specific to mpd-now-playable in a future release.
2024-06-22 04:19:39 -04:00
},
"port": {
"default": 6600,
Add field descriptions to the config schema :)
2024-06-22 06:12:23 -04:00
"description": "The port on which to connect to MPD. Unless you're managing multiple MPD servers on one machine for some reason, you probably haven't changed this from the default port, 6600.",
Support a TOML configuration file The new config file currently only configures the same options that were already available through environment variables. However I have ideas for additional features that would be much nicer to support using a structured configuration format like TOML rather than environment variables, so config files exist now! The previous environment variables are still supported and will be used if you don't have a config file. I plan to keep supporting the MPD_HOST and MPD_PORT environment variables forever since they're shared with other MPD clients such as mpc, but I may eventually drop the environment variables specific to mpd-now-playable in a future release.
2024-06-22 04:19:39 -04:00
"maximum": 65535,
"minimum": 1,
Significantly overhaul configuration management Everything now uses bog-standard Python dataclasses, with Pydantic providing validation and type conversion through separate classes using its type adapter feature. It's also possible to define your classes using Pydantic's own model type directly, making the type adapter unnecessary, but I didn't want to do things that way because no actual validation is needed when constructing a Song instance for example. Having Pydantic do its thing only on-demand was preferable. I tried a number of validation libraries before settling on Pydantic for this. It's not the fastest option out there (msgspec is I think), but it makes adding support for third-party types like yarl.URL really easy, it generates a nice clean JSON Schema which is easy enough to adjust to my requirements through its GenerateJsonSchema hooks, and raw speed isn't all that important anyway since this is a single-user desktop program that reads its configuration file once on startup. Also, MessagePack is now mandatory if you're caching to an external service. It just didn't make a whole lot sense to explicitly install mpd-now-playable's Redis or Memcached support and then use pickling with them. With all this fussing around done, I'm probably finally ready to actually use that configuration file to configure new features! Yay!
2024-06-30 10:10:17 -04:00
"title": "Port",
Support a TOML configuration file The new config file currently only configures the same options that were already available through environment variables. However I have ideas for additional features that would be much nicer to support using a structured configuration format like TOML rather than environment variables, so config files exist now! The previous environment variables are still supported and will be used if you don't have a config file. I plan to keep supporting the MPD_HOST and MPD_PORT environment variables forever since they're shared with other MPD clients such as mpc, but I may eventually drop the environment variables specific to mpd-now-playable in a future release.
2024-06-22 04:19:39 -04:00
"type": "integer"
}
},
Significantly overhaul configuration management Everything now uses bog-standard Python dataclasses, with Pydantic providing validation and type conversion through separate classes using its type adapter feature. It's also possible to define your classes using Pydantic's own model type directly, making the type adapter unnecessary, but I didn't want to do things that way because no actual validation is needed when constructing a Song instance for example. Having Pydantic do its thing only on-demand was preferable. I tried a number of validation libraries before settling on Pydantic for this. It's not the fastest option out there (msgspec is I think), but it makes adding support for third-party types like yarl.URL really easy, it generates a nice clean JSON Schema which is easy enough to adjust to my requirements through its GenerateJsonSchema hooks, and raw speed isn't all that important anyway since this is a single-user desktop program that reads its configuration file once on startup. Also, MessagePack is now mandatory if you're caching to an external service. It just didn't make a whole lot sense to explicitly install mpd-now-playable's Redis or Memcached support and then use pickling with them. With all this fussing around done, I'm probably finally ready to actually use that configuration file to configure new features! Yay!
2024-06-30 10:10:17 -04:00
"title": "MpdConfig",
Support a TOML configuration file The new config file currently only configures the same options that were already available through environment variables. However I have ideas for additional features that would be much nicer to support using a structured configuration format like TOML rather than environment variables, so config files exist now! The previous environment variables are still supported and will be used if you don't have a config file. I plan to keep supporting the MPD_HOST and MPD_PORT environment variables forever since they're shared with other MPD clients such as mpc, but I may eventually drop the environment variables specific to mpd-now-playable in a future release.
2024-06-22 04:19:39 -04:00
"type": "object"
}
},
Significantly overhaul configuration management Everything now uses bog-standard Python dataclasses, with Pydantic providing validation and type conversion through separate classes using its type adapter feature. It's also possible to define your classes using Pydantic's own model type directly, making the type adapter unnecessary, but I didn't want to do things that way because no actual validation is needed when constructing a Song instance for example. Having Pydantic do its thing only on-demand was preferable. I tried a number of validation libraries before settling on Pydantic for this. It's not the fastest option out there (msgspec is I think), but it makes adding support for third-party types like yarl.URL really easy, it generates a nice clean JSON Schema which is easy enough to adjust to my requirements through its GenerateJsonSchema hooks, and raw speed isn't all that important anyway since this is a single-user desktop program that reads its configuration file once on startup. Also, MessagePack is now mandatory if you're caching to an external service. It just didn't make a whole lot sense to explicitly install mpd-now-playable's Redis or Memcached support and then use pickling with them. With all this fussing around done, I'm probably finally ready to actually use that configuration file to configure new features! Yay!
2024-06-30 10:10:17 -04:00
"$id": "https://cdn.00dani.me/m/schemata/mpd-now-playable/config-v1.json",
"$schema": "https://json-schema.org/draft/2020-12/schema",
"properties": {
"cache": {
"description": "A URL describing a cache service for mpd-now-playable to use. Supported protocols are memory://, redis://, and memcached://.",
"format": "uri",
"title": "Cache",
"type": "string"
},
"mpd": {
"$ref": "#/$defs/MpdConfig"
Refactor Cocoa stuff into a 'receiver' The idea here is that there are other places that might want to know what's playing, besides MPNowPlayingInfoCenter. For example, to expose the now playing info to Übersicht efficiently, it needs to be available from a web browser, ideally using WebSockets. So there could be a receiver that runs a small WebSockets server and sends out now playing info to anyone who connects. Additionally, I hope to write receivers for MPRIS and for the System Media Transport Controls on Windows, making mpd-now-playable equally useful across all platforms. None of this is implemented yet, of course, but I hope to get the WebSockets receiver done pretty soon! I'm going to keep the default behaviour unchanged. Unless you explicitly configure different receivers in config.toml, mpd-now-playable will just behave as an MPNowPlayingInfoCenter integration as it's always done.
2024-07-08 22:52:49 -04:00
},
"receivers": {
"default": [
{
"kind": "cocoa"
}
],
"items": {
"discriminator": {
"mapping": {
"cocoa": "#/$defs/CocoaReceiverConfig"
},
"propertyName": "kind"
},
"oneOf": [
{
"$ref": "#/$defs/CocoaReceiverConfig"
}
]
},
"title": "Receivers",
"type": "array"
Significantly overhaul configuration management Everything now uses bog-standard Python dataclasses, with Pydantic providing validation and type conversion through separate classes using its type adapter feature. It's also possible to define your classes using Pydantic's own model type directly, making the type adapter unnecessary, but I didn't want to do things that way because no actual validation is needed when constructing a Song instance for example. Having Pydantic do its thing only on-demand was preferable. I tried a number of validation libraries before settling on Pydantic for this. It's not the fastest option out there (msgspec is I think), but it makes adding support for third-party types like yarl.URL really easy, it generates a nice clean JSON Schema which is easy enough to adjust to my requirements through its GenerateJsonSchema hooks, and raw speed isn't all that important anyway since this is a single-user desktop program that reads its configuration file once on startup. Also, MessagePack is now mandatory if you're caching to an external service. It just didn't make a whole lot sense to explicitly install mpd-now-playable's Redis or Memcached support and then use pickling with them. With all this fussing around done, I'm probably finally ready to actually use that configuration file to configure new features! Yay!
2024-06-30 10:10:17 -04:00
}
},
"title": "Config",
Support a TOML configuration file The new config file currently only configures the same options that were already available through environment variables. However I have ideas for additional features that would be much nicer to support using a structured configuration format like TOML rather than environment variables, so config files exist now! The previous environment variables are still supported and will be used if you don't have a config file. I plan to keep supporting the MPD_HOST and MPD_PORT environment variables forever since they're shared with other MPD clients such as mpc, but I may eventually drop the environment variables specific to mpd-now-playable in a future release.
2024-06-22 04:19:39 -04:00
"type": "object"
}
Copy permalink