With the latest versions of Spotify on Linux (e.g: 0.6.1.309.gb871a7d0, 0.6.2.291.gcccc1f58) the DBus interface has changed a little which has resulted in the need to make some changes so that the playing status is tracked correctly.

The code can be found here on github as a Gist or the raw file.

I’ve recently updated the spotify notifier example I’d previously posted as an example along with my spotify screensaver script. First, I made an update to have it listen to the PropertiesChanged signal. Annoyingly for some unknown reason this signal isn’t visible in D-feet which had led to the erroneous assumption it wasn’t implemented.

Implementing Album Art

After getting it working again, I started to think about how it would be nice to add album art. So I rigged up the script to the last.fm API to grab album art. I’d have preferred to pull the album art from spotify or via open.spotify.com, but annoyingly there doesn’t seem to be a way to get the album art url without scraping, which just seemed too much of a kludge. If anyone knows how to get album art from the spotify cache (assuming it’s there) then I’d be interested to hear about it.

Listening for Spotify announcing itself on D-Bus

Once I had that done, I then thought about how this script would run. Ideally it needs to run before spotify is necessarily open. This causes a problem though because if you try and listen for D-Bus events when the app in question isn’t running you’ll get an error.

So I used the NameOwnerChanged signal and listened for Spotify joining D-Bus and leaving it again. This then provided all that was needed to turn on or off the listener for the PropertiesChanged signal that fires when the track changes.

Also I added a check to try and set-up the PropertiesChanged listener at start-up in-case spotify is already running when the script is launched.

The code

#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
Title: Spotify Notification Demo
Author: Stuart Colville, http://muffinresearch.co.uk
License: BSD

"""

import os
import dbus
import gobject
import pynotify
import httplib2
from urllib import quote
from cgi import escape
from xml.dom.minidom import parseString
from hashlib import md5
from dbus.mainloop.glib import DBusGMainLoop
from dbus.exceptions import DBusException

LASTFM_API_KEY = os.environ.get("LASTFM_API_KEY")
HTTP_CACHE_DIR = os.path.expanduser("~/.cache/spotify/http/")
IMAGE_CACHE_DIR = os.path.expanduser("~/.cache/spotify/art/")
BASE_URL = ("https://ws.audioscrobbler.com/2.0/?method=album."
            "getinfo&api_key=%s&artist=%%s&album=%%s" % LASTFM_API_KEY)

MISSING = os.path.realpath(os.path.join(os.path.dirname(__file__), "missing.png"))

if not os.path.isdir(HTTP_CACHE_DIR):
    os.makedirs(HTTP_CACHE_DIR)
if not os.path.isdir(IMAGE_CACHE_DIR):
    os.makedirs(IMAGE_CACHE_DIR)

class SpotifyNotifier(object):

    def __init__(self):
        """initialise."""
        bus_loop = DBusGMainLoop(set_as_default=True)
        self.bus = dbus.SessionBus(mainloop=bus_loop)
        loop = gobject.MainLoop()
        self.http = httplib2.Http(HTTP_CACHE_DIR)
        self.notify_id = None
        try:
            self.props_changed_listener()
        except DBusException, e:
            if not ("org.mpris.MediaPlayer2.spotify "
                    "was not provided") in e.get_dbus_message():
                raise
        self.session_bus = self.bus.get_object("org.freedesktop.DBus",
                                 "/org/freedesktop/DBus")
        self.session_bus.connect_to_signal("NameOwnerChanged",
                                        self.handle_name_owner_changed,
                                        arg0="org.mpris.MediaPlayer2.spotify")

        loop.run()

    def props_changed_listener(self):
        """Hook up callback to PropertiesChanged event."""
        self.spotify = self.bus.get_object("org.mpris.MediaPlayer2.spotify",
                                           "/org/mpris/MediaPlayer2")
        self.spotify.connect_to_signal("PropertiesChanged",
                                        self.handle_properties_changed)

    def handle_name_owner_changed(self, name, older_owner, new_owner):
        """Introspect the NameOwnerChanged signal to work out if spotify has started."""
        if name == "org.mpris.MediaPlayer2.spotify":
            if new_owner:
                # spotify has been launched - hook it up.
                self.props_changed_listener()
            else:
                self.spotify = None

    def handle_properties_changed(self, interface, changed_props, invalidated_props):
        """Handle track changes."""
        metadata = changed_props.get("Metadata", {})
        if metadata:
            if pynotify.init("Spotify Notifier Demo"):

                title = unicode(metadata.get("xesam:title").encode("latin1"))
                album = unicode(metadata.get("xesam:album").encode("latin1"))
                artist = unicode(metadata.get("xesam:artist").encode("latin1"))
                hash_ = md5()
                hash_.update("%s-%s" % (artist, album))
                hash_path = hash_.hexdigest()
                image_path = os.path.join(IMAGE_CACHE_DIR, hash_path)
                if not os.path.exists(image_path):
                    url = BASE_URL % (escape(quote(artist.encode("utf8"))),
                                       escape(quote(album.encode("utf8"))))
                    response, content = self.http.request(url, "GET")
                    dom = parseString(content)
                    images = dom.getElementsByTagName("image")
                    for image in images:
                        for attr, value in image.attributes.items():
                            if attr == "size" and value == "medium":
                                image_url = None
                                if image and image.firstChild:
                                    image_url = image.firstChild.nodeValue
                                if image_url:
                                    response, image_contents = \
                                                self.http.request(image_url)
                                    if image_contents:
                                        fh = open(image_path, "w")
                                        fh.write(image_contents)
                                        fh.close()            

                if not os.path.exists(image_path):
                    image_path = MISSING

                alert = pynotify.Notification(title,
                              "by %s from %s" % (artist, album), image_path)
                if self.notify_id:
                    alert.props.id = self.notify_id
                alert.set_urgency (pynotify.URGENCY_NORMAL)
                alert.show()
                self.notify_id = alert.props.id

if __name__ == "__main__":
    SpotifyNotifier()

Pre-requisites

• Spotify for Linux
• A Spotify unlimited or premium account
• Install httplib2: sudo apt-get install python-httplib2 (I think that’s the only dep that isn’t installed by default)
• Set-up the script as outlined below.

Getting the code

The code is available in a bzr branch here: code.projectfondue.com

To run it check it out and follow the notes in the README file. No doubt there might be some bugs so feel free to let me know of any possible improvements that can be made to it.

Pathogen

pathogen is a helper for modifying the runtimepath. This makes it possible to branch a plugin from github to .vim/bundle and then pathogen will ensure that it’s added to the runtime path.

To make this work first you need to download pathogen and place it in .vim/autoload

Next add the following to your .vimrc file:

call pathogen#runtime_append_all_bundles()

Once you have done this simple check-out the branches of your favorite vim plugins to .vim/bundle and that's it.

Scripting plugin updates

To make life even easier I knocked up a very crude python script and Makefile to clone all my favorite plugins when I run "make get" and update them when I run "make update".

It's crude because currently it only cares about git (currently all the plugins I care about are on github) and it doesn't currently allow revs to be specified. Though both of these features could be fairly easily added. Anyway, in-case it's useful as a starting point to for someone else, here's the script:

Also if you're using git to version your branch (I'm not). Then you could use git submodules to achieve a similar effect.

#!/usr/bin/env python

import os
import sys
import subprocess

BUNDLE_DIR = os.path.expanduser("~/.vim/bundle")

plugin_branches = {
    "git": [
        "git://github.com/tomtom/tlib_vim.git",
        "git://github.com/garbas/vim-snipmate.git",
        "git://github.com/scrooloose/nerdtree.git",
        "git://github.com/scrooloose/syntastic.git",
        "git://github.com/MarcWeber/vim-addon-mw-utils.git",
        "git://github.com/scrooloose/nerdcommenter.git",
    ],
}

def get():
    os.chdir(BUNDLE_DIR)
    for vcs_type, branches in plugin_branches.items():
        if vcs_type == "git":
            for branch in branches:
                subprocess.call(["git", "clone", branch])

def update():
    os.chdir(BUNDLE_DIR)
    for vcs_type, branches in plugin_branches.items():
        if vcs_type == "git":
            for branch in branches:
                subdir = os.path.split(branch)[-1][:-4]
                os.chdir(subdir)
                subprocess.call(["git", "pull"])
                os.chdir("../")

if __name__ == "__main__":
    args = sys.argv
    if args and len(args) > 1:
        if args[1] == "get":
            sys.exit(get())
        elif args[1] == "update":
            sys.exit(update())

If you save this somewhere as deps.py you can then run it as python deps.py get and python deps.py update. I use a simple Makefile to do this.

The code is deliberately structured to make it easy to modify if you wanted to add mercurial or bzr support. That is left as an excercise for the reader.

It's likely I will update this script in due course, to keep up to date with that and any other aspects of my vim conf you can get the whole thing from here: lp:~muffinresearch/+junk/dotvim

This isn’t anything new but I thought I would share my experiences of trying to free space on my HTC desire by forcing apps to be movable to the sd card using the android SDK on linux.

WARNING: Ensure you have a backup of any important data before you start in case something goes wrong. Carrying out these instructions is at your own risk.

Running out of space is really the only annoyance I have come across since owning an android phone. Every now and again the low space icon comes up and you have to try and free up some space.

Since Froyo you’ve been able to move certain apps to SD card, but it’s only if the developer allows it. If you’re an android developer and you want to know how to do it, see this post: Enabling the Android Move To SD Card Feature

So if you’re stuck with a bunch of apps you can’t move by default because “Move to SD Card” is greyed out in “Settings -> Applications -> Manage Applications -> Appname” then you might be thinking it’s not possible. However, it is possible to change the default install location to SD card via adb.

Introducing the Android Debug Bridge

Adb is the Android Debug Bridge which comes as part of the SDK. If you don’t have the SDK the first thing you will need to do is install it (get it fromdeveloper.android.com). Once you have the SDK you can find the adb tool in <sdk>/platform-tools/, though in my case I have it at <sdk>/tools/.

Update 2012-01-26: You may find when you unpack the SDK adb isn’t there. If that’s the case you may need to run the “android” program (./android under linux) to be shown a window which provides a way to download platform-tools. once you have installed that you should find adb there.

After you’ve installed the SDK you’ll need to connect your phone to your computer using the USB data cable. You’ll also need to make sure that debugging is possible by visiting “Settings -> Applications -> Development” and checking “USB Debugging”.

Enabling moving of apps to SD card

To change the the install location we are going to run the pm command via the adb shell. Here’s the details of the pm command:

The setInstallLocation command changes the default install location
  0 [auto]: Let system decide the best location
  1 [internal]: Install on internal device storage
  2 [external]: Install on external media

To change the default install location to the SD card (which also enables moving most apps to the SD card.) run the following from the dir containing the adb command:

./adb shell pm setInstallLocation 2

If you at any point hit the following:

error: insufficient permissions for device

Try doing this:

./adb kill-server
sudo ./adb  start-server

You should now find you can run the above commands without error.

Insufficient Storage Available

The other error I had was that when I was trying to move any app after changing the default install location to the SD card was something along the lines of “Unable to move application. Insufficient Storage”.

The way I got around this was to uninstall twitter which was using about 17mb (it was the largest app). After that I re-installed it and it used far less space (naturally as the data would have been removed by the re-install process). After that I was able to successfully move most of my remaining apps (twitter included) to my SD card.

Re-setting the installation location back to auto

I’d strongly recommend re-setting the default installation location when you are done moving apps. The reason for this is that apps will fail to be installed directly to the external location, at least this is what I experienced when trying to re-install the twitter app.

To reset the install location to automatic (let the system decide) use the following:

./adb shell pm setInstallLocation 0

Should you forget where it was left at you can always run:

./adb shell pm getInstallLocation

e.g:

$ ./adb shell pm getInstallLocation
0[auto]

The latest version of the spotify client for linux (0.4.8) has added partial mpris support.

This is great as it means controlling spotify via D-bus is far easier than the previous hacks using wmctrl and xvkbd.

I’ve updated the screensaver toggle script to use spotify’s D-bus interface to play/pause spotify. This also means that I’ve been able to de-couple the script from having to run the screensaver which a big improvement on the old version.

To run it just add the script to your start-up items.

Here’s the code, which is a lot more concise compared to the previous version.

Updated to use Mpris2 as of revision 9 for v0.4.8.306…

#!/usr/bin/env python

"""
Title: Spotify Screensaver Toggle
Author: Stuart Colville, http://muffinresearch.co.uk/
License: BSD

Requires Spotify Linux Preview.

Usage:

 * Save the script
 * Ensure it is executable: chmod +x /path/to/script
 * Add the script to your start-up items. 

"""

import dbus
import gobject
from dbus.mainloop.glib import DBusGMainLoop

class SpotifyScreenSaverPause(object):
    """This pauses and plays spotify when the screensaver is activated"""

    def __init__(self):
        """init class."""
        dbus_loop = DBusGMainLoop(set_as_default=True)
        self.bus = dbus.SessionBus(mainloop = dbus_loop)
        self.loop = gobject.MainLoop()
        self.start_listen()
        self.was_playing = 0
        self.loop.run()

    def start_listen(self):
        """Listen to screensaver ActiveChanged events from dbus."""
        screensaver = self.bus.get_object('org.gnome.ScreenSaver',
                                                  '/org/gnome/ScreenSaver')
        screensaver.connect_to_signal("ActiveChanged", self.play_pause)

    def play_pause(self, *args, **kwargs):
        """Toggle play/pause."""
        try:
            spotify = self.bus.get_object("org.mpris.MediaPlayer2.spotify", "/")
            spotify_iface = dbus.Interface(spotify, dbus_interface="org.freedesktop.MediaPlayer2")
            if self.was_playing:
                spotify_iface.Play()
                self.was_playing = 0
            else:
                if spotify_iface.GetMetadata():
                    self.was_playing = 1
                spotify_iface.Pause()
        except dbus.exceptions.DBusException, e:
            # Ignore exception caused by spotify not being started.
            if e.get_dbus_name() != 'org.freedesktop.DBus.Error.ServiceUnknown':
                raise

if __name__ == "__main__":
    ss = SpotifyScreenSaverPause()

See the latest version of the code here Spotify Screensaver Toggle

If you want to investigate what’s possible with D-bus and spotify, D-feet is an excellent tool for investigating D-bus:

Click for a larger version.

Further Examples

Here’s an example to get the metadata from a track currently playing. (Note: if Spotify isn’t playing this will be an empty dictionary.)

>>> import dbus
>>> bus = dbus.SessionBus()
>>> spotify = bus.get_object("org.mpris.spotify", "/")
>>> spotify_iface = dbus.Interface(spotify, dbus_interface="org.freedesktop.MediaPlayer")
>>> spotify_iface.GetMetadata()
dbus.Dictionary({dbus.String(u'album'): dbus.String(u'Getz/Gilberto #2', variant_level=1), dbus.String(u'title'): dbus.String(u"Here's That Rainy Day", variant_level=1), dbus.String(u'artist'): dbus.String(u'Stan Getz', variant_level=1), dbus.String(u'year'): dbus.Int32(1964, variant_level=1), dbus.String(u'location'): dbus.String(u'spotify:track:1RIfT0Y0TwP2M38pLLfDeJ', variant_level=1), dbus.String(u'time'): dbus.UInt32(242L, variant_level=1), dbus.String(u'tracknumber'): dbus.Int32(4, variant_level=1)}, signature=dbus.Signature('sv'))
>>> print spotify_iface.GetMetadata().get("title")
Here's That Rainy Day
>>> print spotify_iface.GetMetadata().get("location")
spotify:track:1BTO5gV9xSAB7EOBKSlcFY
>>>

With the latest Spotify update to use MPRIS2 (0.4.8.306.xxx) – the TrackChanged signal has gone and there’s no PropertiesChanged signal as per MPRIS2 spec http://www.mpris.org/2.0/spec/ I’ll update the notification example script below as soon as that is rectified. It was there all along. I’ve updated the code to reflect the use of PropertiesChanged

To take that example further here’s a demo that listens to the TrackChangedPropertiesChanged event. It uses the notification id so we can replace the notification details as you move through the tracks. This avoids waiting for the timeout before displaying the current track information.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
Title: Spotify Notification Demo
Author: Stuart Colville, http://muffinresearch.co.uk
License: BSD

"""

import dbus
import gobject
from dbus.mainloop.glib import DBusGMainLoop
import pynotify

class SpotifyNotifier(object):

    def __init__(self):
        """initialise."""
        bus_loop = DBusGMainLoop(set_as_default=True)
        bus = dbus.SessionBus(mainloop=bus_loop)
        loop = gobject.MainLoop()
        self.spotify = bus.get_object("org.mpris.MediaPlayer2.spotify", "/org/mpris/MediaPlayer2")
        self.spotify.connect_to_signal("PropertiesChanged", self.track_changed)
        self.notify_id = None
        loop.run()

    def track_changed(self, interface, changed_props, invalidated_props):
        """Handle track changes."""
        metadata = changed_props.get("Metadata", {})
        if metadata:
            if pynotify.init("Spotify Notifier Demo"):

                title = unicode(metadata.get("xesam:title").encode("latin1"))
                album = unicode(metadata.get("xesam:album").encode("latin1"))
                artist = unicode(metadata.get("xesam:artist").encode("latin1"))

                alert = pynotify.Notification(title,
                                 "by %s from %s" % (artist, album))
                if self.notify_id:
                    alert.props.id = self.notify_id
                alert.set_urgency (pynotify.URGENCY_NORMAL)
                alert.show()
                self.notify_id = alert.props.id

if __name__ == "__main__":
    SpotifyNotifier()

Note this notification demo assumes spotify is running to set-up the listener, so it’s not something you can just set running at start-up unless you use it to wrap the start-up of spotify.

Both scripts are BSD licensed so feel free to use and adapt to your own purposes.

All that was required was something to pretend to be a real SMTP service as we didn’t need to view the messages at all.

Here’s the snippet I came up with using the smtpd module in Python:

#!/usr/bin/env python
"""A noddy fake smtp server."""

import smtpd
import asyncore

class FakeSMTPServer(smtpd.SMTPServer):
    """A Fake smtp server"""

    def __init__(*args, **kwargs):
        print "Running fake smtp server on port 25"
        smtpd.SMTPServer.__init__(*args, **kwargs)

    def process_message(*args, **kwargs):
        pass

if __name__ == "__main__":
    smtp_server = FakeSMTPServer(('localhost', 25), None)
    try:
        asyncore.loop()
    except KeyboardInterrupt:
        smtp_server.close()

To use this, save the above as fake_stmp.py and:

chmod +x fake_smtp.py
sudo ./fake_smtp.py

NOTE: Running this requires sudo to bind to port 25 as binding any port < 1024 requires superuser privileges.

Clearly you could easily adapt that to do something more useful if you want to see what's in the messages sent, either by writing messages to a file or printing them to stdout.

If printing them to stdout is what you need then there's also smtpd.DebuggingServer which is a subclass of SMTPServer which prints messages out to stdout. Using that is even easier and can be done with the following one liner:

sudo python -m smtpd -n -c DebuggingServer localhost:25

Again we use sudo in this case because we’re using port 25 if you don’t want that you can use a port higher than 1024.

To test this out we can use telnet like so:

$ telnet localhost 25
Trying 127.0.0.1...
Connected to localhost.localdomain.
Escape character is '^]'.
220 localhost6.localdomain6 Python SMTP proxy version 0.2
HELO localhost
250 localhost6.localdomain6
MAIL FROM: test@test.com
250 Ok
RCPT TO: test@testing.com
250 Ok
DATA
354 End data with .
subject: Hello
to: test@test.com
This is my message
.
250 Ok
QUIT
221 Bye
Connection closed by foreign host.

Over on the terminal running the debugging server you should see the following:

$ sudo python -m smtpd -n -c DebuggingServer localhost:25
[sudo] password for moo:
---------- MESSAGE FOLLOWS ----------
subject: Hello
to: test@test.com
This is my message
------------ END MESSAGE ------------

I’ve recently found it really hurts my eyes when working late at night going from a terminal (which is black background and light text) to a browser window like google.com with a large expanse of white.

To help with this I’ve been looking for ways to reduce the screen brightness.

The solution I’ve come up with on Ubuntu is to use Compiz to invert the screen colours. If you open CompizConfig Settings Manager and look for Negative under Accessibility all you need to do is make sure it’s enabled and set a keystroke to toggle the inversion. By default it inverts everything within the window. However when you have terminals set to dark backgrounds like I do you don’t want those to be inverted and become glaring white backgrounds with dark text. Fortunately Compiz provides a feature to exclude certain windows.

Here’s an example for the “Exclude Windows” field to exclude the Desktop (a default), Guake and Gnome-terminal from being inverted.

(type=Desktop) | class=Guake.py | class=Gnome-terminal

If you use a mac you should be able to achieve the raw inversion with “Control Option Command 8″

Great. Now all I need is a silencer for my clacky keyboard!

New version: I’ve updated the script to use D-bus with spotify for Linux version 0.4.8 see Spotify Screensaver Toggle with D-bus for further information.

In a previous post, Lock Screen and Pause Spotify I provided a rudimentary script to pause spotify when your screensaver kicks in. Now with the Spotify Linux preview being available I’ve started using (and paying for) a Spotify unlimited subscription. I decided I wanted to update the script to be able to pause Spotify when the screen is locked and also start playing after I log-in.

Initially I was hoping to do all of this by listening to Dbus events for when the screensaver is activated/deactivated. However, for some reason it’s not possible to play/pause spotify based on the DBus event saying that the screensaver is active (Presumably because it’s not possible to focus a window after the screensaver is active). Because of this current limitation the workaround is use this script to lock the screen for you. This way it locks the screen after it has set-up the listeners for the screensaver Dbus events.

When the screensaver is de-activated the script fires off the function to get Spotify playing again but only if it was playing before the screensaver was activated.

When spotify has an api, it will then make sense to use that instead, which should mean that this script can then be completely run by listening to dbus events which would be much more elegant.

Dependencies

The deps are the same as before – here’s the incantation to install them for Ubuntu.

sudo apt-get install wmctrl xvkbd

Usage

To set it up, link the script to somewhere in your path and then create a keystroke in “System -> Preferences -> Keyboard Shortcuts” to lock the screen. Once that’s done, you should see the screen lock when that keystroke is executed and Spotify will be paused if it was playing.

Get the code

You can grab the code from here. Feel free to send me improvements or suggestions on how to make it better.

Known issue: I’ve noticed a bug in that it doesn’t pause if the window is hidden. This is tricky as it’s not visible to the window list. Suggestions how to workaround this are welcomed.

Additional thanks

Tommy Mattila’s Spotify Control which was based on my original script, provided useful insight into handling the active window.

$ sudo puppetd -t
err: Could not retrieve catalog from remote server: undefined method `closed?' for nil:NilClass
warning: Not using cache on failed catalog
err: Could not retrieve catalog; skipping run

Certainly not the most enlightening error message. After checking over the syntax of my mainfests it still wasn’t obvious what was wrong.

First port of call to diagnose the problem is to try enabling debugging on the client:

On the client:

# Run the client with debugging enabled.
$ sudo puppetd -t --debug

If that yields nothing useful try the following:

On the puppetmaster run:

# If it's running stop the puppetmasterd service
# change this to suit your distro - the following is debian specific
$ sudo /etc/init.d/puppetmaster stop 

# start the puppetmasterd in debug mode without daemonizing it.
$ sudo puppetmasterd --no-daemonize --debug

Back on the client re-run the puppetd:

$ sudo puppetd -t

By looking at the debug output on the puppetmaster I was able to see my problem which was that a generate command didn’t have permission to write a necessary file. Once I’d fixed it everything worked as expected.

Once finished ctrl-c the foreground puppetmasterd and restart the service if you’d stopped it to run it in debug mode:

$ sudo /etc/init.d/puppetmaster start

$ ec2stop i-XXXXXXXX
Unexpected error:
java.net.SocketException: Invalid argument or cannot assign requested address
	at java.net.PlainSocketImpl.socketConnect(Native Method)
	at java.net.AbstractPlainSocketImpl.doConnect(AbstractPlainSocketImpl.java:310)
	at java.net.AbstractPlainSocketImpl.connectToAddress(AbstractPlainSocketImpl.java:176)
	at java.net.AbstractPlainSocketImpl.connect(AbstractPlainSocketImpl.java:163)
	at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:384)
        ----- snip ------

I found to enable ec2-api-tools commands to work it’s necessary to switch over to using the sun jre.

Note: In lucid open-jdk is the default java and sun-java6-jre is now found in the partner repos.

You can do this if you have the sun-java6-jre package with the following:

sudo update-alternatives --config java

And select the correct version interactively.

Should you need to add the Lucid partner repo you can use the following:

sudo add-apt-repository "deb http://archive.canonical.com/ lucid partner"