Personal Programming Plans: Instagram2Background

I have this code which uses WebService::Instagram to grab my most recent picture from Instagram and set it as background image on my Ubuntu machines. I put it in my crontab and it just works.

view plainprint?

1. #!/usr/bin/env perl  
2.   
3. use feature qw'say' ;  
4. use strict ;  
5. use warnings ;  
6.   
7. use Cwd 'abs_path' ;  
8. use Data::Dumper ;  
9. use IO::Interactive qw{ interactive } ;  
10. use Try::Tiny ;  
11. use YAML::XS qw{ LoadFile DumpFile } ;  
12.   
13. use lib '/home/jacoby/lib' ;  
14. use Instagram ;  
15.   
16. my $config_file = join '/', $ENV{HOME}, '.i2b.yml' ;  
17. my $config = LoadFile($config_file) ;  
18.   
19. my $token    = $config->{user}{access_token} ;  
20. my $id       = $config->{user}{id} ;  
21. my $template = 'https://api.instagram.com/v1/users/XX/media/recent' ;  
22. my $ig       = connect($config) ;  
23.   
24. $ig->set_access_token($token) ;  
25. my $url = $template ;  
26. $url =~ s/XX/$id/ ;  
27. my $feed        = $ig->request($url) ;  
28. my $data        = $feed->{data} ;  
29. my @data        = grep { $_->{type} eq 'image' } @$data ;  
30. my $most_recent = $data[0] ;  
31. my $file        = '/home/jacoby/.i2b/i2b.jpg' ;  
32.   
33. my $image_id    = $most_recent->{id} ;  
34. my $image_url   = $most_recent->{images}->{standard_resolution}->{url} ;  
35. my $image_text  = $most_recent->{caption}->{text} ;  
36.   
37. if ( $config->{done} ne $image_id ) {  
38.     my $image = imagegrab($image_url) ;  
39.     imagewrite( $file, $image ) ;  
40.     say {interactive} $image_id ;  
41.     say {interactive} $image_text ;  
42.     $config->{done} = $image_id ;  
43.     }  
44. imageset($file) ;  
45.   
46. DumpFile( $config_file, $config ) ;  
47.   
48. exit ;  
49.   
50. # takes a URL, returns the raw content  
51. sub imagegrab {  
52.     my $url      = shift ;  
53.     my $agent    = new LWP::UserAgent ;  
54.     my $request  = new HTTP::Request( 'GET', $url ) ;  
55.     my $response = $agent->request($request) ;  
56.     if ( $response->is_success ) {  
57.         return $response->content ;  
58.         }  
59.     return undef ;  
60.     }  
61.   
62. # takes an filename and an image, and writes image to filename  
63. sub imagewrite {  
64.     my $file  = shift ;  
65.     my $image = shift ;  
66.     if ( open my $fh, '>', $file ) {  
67.         print $fh $image ;  
68.         close $fh ;  
69.         return 1 ;  
70.         }  
71.     return 0 ;  
72.     }  
73.   
74. # takes a filename, sets it as backgroundimages  
75. sub imageset {  
76.     my $img = shift ;  
77.   
78.     return unless $img ;  
79.     my $command = join ' ', qw{  
80.         gsettings set  
81.         org.gnome.desktop.background  
82.         picture-uri  
83.         } ;  
84.     my $command2 = join ' ', qw{  
85.         gsettings set  
86.         org.gnome.desktop.background  
87.         picture-options  
88.         } ;  
89.   
90.     my $bg = '"file://' . abs_path $img . '"' ;  
91.     qx{$command $bg} ;  
92.     qx{$command2 'zoom'} ;  
93.     }  

#!/usr/bin/env perl

use feature qw'say' ;
use strict ;
use warnings ;

use Cwd 'abs_path' ;
use Data::Dumper ;
use IO::Interactive qw{ interactive } ;
use Try::Tiny ;
use YAML::XS qw{ LoadFile DumpFile } ;

use lib '/home/jacoby/lib' ;
use Instagram ;

my $config_file = join '/', $ENV{HOME}, '.i2b.yml' ;
my $config = LoadFile($config_file) ;

my $token    = $config->{user}{access_token} ;
my $id       = $config->{user}{id} ;
my $template = 'https://api.instagram.com/v1/users/XX/media/recent' ;
my $ig       = connect($config) ;

$ig->set_access_token($token) ;
my $url = $template ;
$url =~ s/XX/$id/ ;
my $feed        = $ig->request($url) ;
my $data        = $feed->{data} ;
my @data        = grep { $_->{type} eq 'image' } @$data ;
my $most_recent = $data[0] ;
my $file        = '/home/jacoby/.i2b/i2b.jpg' ;

my $image_id    = $most_recent->{id} ;
my $image_url   = $most_recent->{images}->{standard_resolution}->{url} ;
my $image_text  = $most_recent->{caption}->{text} ;

if ( $config->{done} ne $image_id ) {
    my $image = imagegrab($image_url) ;
    imagewrite( $file, $image ) ;
    say {interactive} $image_id ;
    say {interactive} $image_text ;
    $config->{done} = $image_id ;
    }
imageset($file) ;

DumpFile( $config_file, $config ) ;

exit ;

# takes a URL, returns the raw content
sub imagegrab {
    my $url      = shift ;
    my $agent    = new LWP::UserAgent ;
    my $request  = new HTTP::Request( 'GET', $url ) ;
    my $response = $agent->request($request) ;
    if ( $response->is_success ) {
        return $response->content ;
        }
    return undef ;
    }

# takes an filename and an image, and writes image to filename
sub imagewrite {
    my $file  = shift ;
    my $image = shift ;
    if ( open my $fh, '>', $file ) {
        print $fh $image ;
        close $fh ;
        return 1 ;
        }
    return 0 ;
    }

# takes a filename, sets it as backgroundimages
sub imageset {
    my $img = shift ;

    return unless $img ;
    my $command = join ' ', qw{
        gsettings set
        org.gnome.desktop.background
        picture-uri
        } ;
    my $command2 = join ' ', qw{
        gsettings set
        org.gnome.desktop.background
        picture-options
        } ;

    my $bg = '"file://' . abs_path $img . '"' ;
    qx{$command $bg} ;
    qx{$command2 'zoom'} ;
    }

With IFTTT, it's even easier on Android.

But I don't spend all my time with just Android and Ubuntu. I spend a fair amount of time in Windows. I have a start with that: I can use C# to set an image to the background. This is the first step. I know, at least a little, about scheduling tasks in Windows, which is the last step.

So, the coming steps:

• Using C# to get the Instagram JSON
• Using C# to parse the Instagram JSON and pull URL of newest image
• Using C# to download said image. Certainly related to getting the JSON.
• Using C# to write image file to Windows equivalent to /tmp (because this will be released to others).
• Knowing what Windows for /tmp is.
• Knowing where to hold my Instagram OAuth token data.

Seems like a small number of things to get done, once I sit down to do them. I just need to sit down, do them, and build the tool again.

Quantified Self: For What?

This is my daily step count since I first got a FitBit in 2012, in handy heatmap form.

It shows that 2014 was a pretty active year.

It shows that this year, I've really fallen off the game.

It shows that the main purpose of this process for me, of learning how to grab the data and plot it in different and hopefully useful ways, has succeeded.

It shows, really, that I'm much more about collecting the data than using it to change my life.

And I can only see that as a failure.

I've built other things on top of this. My daily steps pop up in my Twitter feed and bash prompt. If I my battery gets low, I get notified on my tablet. If I go several days without a connection (if the battery dies without me noticing, or if I lose it, as I have done recently), I also get notified. I've made it very convenient to me.

But I failed to make greater amounts of movement an important part of my life. I failed to develop an appreciation for running or walking, at least in comparison to everything else I do.

So, I need to start thinking about how I can change my behavior.

And I probably shouldn't get a replacement FitBit until I have a plan for that.

My Reason to hate Python might be GONE!

Let me show you some code.

view plainprint?

1. #!/usr/bin/env python  
2.   
3. mylist = [0,1,2,3]  
4.   
5. for n in mylist:  
6.  for  m in mylist:  
7.   print m,n  
8.     print m,n  
9.  print n  

#!/usr/bin/env python

mylist = [0,1,2,3]

for n in mylist:
 for  m in mylist:
  print m,n
    print m,n
 print n

Looks pretty normal, right? Just a loop, right? Just a loop within a loop.

Yes it is, but if you look closer, you'll notice two spaces in front of the second print statement.

This is exactly what happened to me the first time I tried Python, about 15 years ago. It was code that showed open machines in ENAD 302, and I ran it on an NT machine I had installed ActiveState Python on. I no longer have that job, thus no longer have that machine and that version of Python. I no longer can find the code, and the computer lab in ENAD 302 is gone.

As is ENAD.

All I have is the memory of having pages of error reports that didn't tell me that the problem was that, halfway into a 200-or-so line Python program. This has lead me to set expandtab or the equivalent for every editor I've used since. Burn me once, shame on you, but burn me twice...

I admit that disliked Python before that, but then it was more "Perl does this already, so why do I have to learn how to do the exact same thing in another dynamic language? What do I gain?" rather than "This language takes as a core feature a means to create undetectable errors."

But no. My hatred of Python stopped coming from a logical place. "Creates undetectable errors" is a logical argument, one that is no longer true, but I got taken to a place of negative emotion, like someone who was bitten by a dog as a child and now is overcome with fear or hate when one comes up now.

(I tried it a few times since, and each time, my experience said "this is an objectively stupid way of doing things", until I bumped into things like Sikuli or my FitBit code where there was either no other way or this was the easiest way to get to "working".)

Then I find someone online who says "tabs are better than spaces". For outputting formatted text, I do agree, but in code, that leads to invisible bugs. So, when someone is wrong online, you correct them.

But then, I wrote the above code, expecting the same errors and received none.

(In this process, I learned some interesting things about Sublime Text, like the way you can set color_scheme and draw_white_space and translate_tabs_to_spaces at a language-specific level, which I did to allow me to see the white space when writing the above code. Sublime Text is neat.)

I've been saying this for a while, but I think this is the last thing I needed to find out before I lived it: the Python that's here today is not the Python that bit me 15 years ago, and I should get over my hangups and "pet the dog".