Tag: programming

It’s a pretty short program, and it doesn’t do as much as I
wish it did, but it will make a tedious and error-prone job a
little bit less tedious.

I’ve mentioned this before, but turning a website from html
into a content-manged site is a pain in the neck, and one of the
most painful things is getting the images and pdf files and such
into the media library, because that’s a terrible web-based
program, that only lets you do one file at a time.

So my program uses the python wordpresslib. It takes
one argument, which is the name of the file to upload. (The url,
username, and password
for the wordpress blog are hard-coded for my purposes.)

The program uploads the file and returns the URL for accessing
the raw file in the media library.

This isn’t really as good as you would hope for — what you’d
want is to supply a title and caption for the item and get the
link that shows the image in your post as a link to the page
page in the media library. You have to do all of that through
the web interface. But at least that web interface is a
reasonable program. The one for uploading gives you two
choices, one of which never works for me and the other one makes
you pick the filename via the browser even if you know it.

I’m glad I got programming energy for this even if it isn’t
much of a program. I think it’s important to use skills like
that pretty often. Of course I’ve been writing some PHP in the
course of the website redesign, but that’s closer to writing
html than it is to real programming.

Here’s the program if you want to use it:


#!/usr/bin/env python

# 09-Aug-20 lconrad; created
# usage: addmedia.py filename
# adds filename as a media object to the serpentpublications.org wordpress blog

# import library
import wordpresslib, sys

if sys.argv < 2:
print "usage: addmedia.py filename"

filename = sys.argv[1]
# note that it's the xmlrpc.php interface you need to specify
wordpress = "http://serpentpublications.org/wordpress/xmlrpc.php"
user = "*redacted*"
password = "*redacted*"

# prepare client object
wp = wordpresslib.WordPressClient(wordpress, user, password)

# select blog id
wp.selectBlog(0)

# upload image for post
imageSrc = wp.newMediaObject(filename)

print "Image uploaded to: %s" % imageSrc

I wrote a few months ago about how I post these
entries. It seems a lot harder than what I do for email.
I type one letter to set up whether I’m writing a new
mail, replying to the sender, or replying to all recipients, and
whether I want the contents of the message I’m replying to in the
reply. Then I write my reply, and press a couple of keys to
send it. All without ever leaving emacs, which is the editor
that’s in my fingers so I don’t have to think about what to do
to move the cursor or delete or reformat.

For a weblog entry, I can edit the actual text in emacs, but
then I have to paste it into my browser and add tags and categories

So a couple of days ago I was catching up on news reading, and there was a
bug reported about weblogger in the emacs help newsgroup, which
indicated that the poster, while hitting an irritating problem,
had gotten farther towards getting it to work than I had, so I
decided to try it again.

Again, I didn’t get anywhere, but I was energetic enough to
send an email someone, who pointed me at someone else, who
answered my initial questions quite calmly and pointed me at the
bug list and the mailing list that he’d set up some time ago.

So I’m basically doing some testing for the developer on a
platform (wordpress) that he doesn’t have easy access to, and I
believe that we’ll eventually get a program that I really want
to have, namely a direct interface between emacs and my blogs.

In this case, both wordpress and emacs are open source
software, and they both use a well-documented protocol, so there
aren’t any insuperable barriers to being able to write this
program that I wish I had — someone just needs to write, document,
test, and debug the code. I’m helping with the documenting and
testing; maybe I’ll at some point get into the debugging, although
I was involved in gnus for several years without ever really
touching the code.