Stephan Sokolow's Blog

As none of you certainly know, my system has a very odd video setup:

• Because I hate bad window management misplacing things when the resolution changes, I’ve used xorg.conf to lock my desktop at 2560×1024
• Because I’m using nVidia TwinView, XRandR tells applications that the entire desktop is one monitor but the window manager still gets the Xinerama hints it needs to interpret fullscreen and maximize as only half of that.
• Games generally assume that you’ll want to play them fullscreen… sometimes not even offering an obvious way to enable windowed mode.
• Since I got my new video card with HDMI for the second monitor, my right monitor is the first one, not my left one.

I think you can see where this might cause a problem. Games tend to exhibit one of the following behaviours:

• Fullscreen across both displays, centered on the big physical gap between screens. (Not since my new video card)
• Fullscreen on the right-hand monitor, center as if fullscreening across both displays. (Since my new video card)
• Fullscreen on one monitor, letterbox to the aspect ratio of the desktop as a whole (YouTube and Cortex Command, I’m looking at you)
• Windowed mode, but only offer 2560×1024 as a resolution unless you edit the config file manually because they naïvely use SDL’s list of fullscreen resolutions for windowed mode too.

This wouldn’t be a huge deal, since I tend to prefer windowed-mode play anyway, except that sometimes, the mouse is mapped wrong too, so you can see the “Options” button but can’t click it.

So far, here are the workarounds I’ve found successful:

1. Just let the stupid things muck with your resolution settings (I’d rather not game instead, but you may feel differently)
2. Manually edit the config file to set windowed mode and a sane resolution. (Most commonly successful option for open-source games. Look for ~/.gamename, ~/.config/gamename, or possibly ~/.local/share/gamename)
3. Check -h, -help, --help, -?, and any README files for an option to start windowed. Try -w, -windowed, and --windowed just in case. (eg. Braid)
4. Try pressing Alt+Enter at the main menu screen (eg. World of Goo)
5. Run it inside Xephyr (Currently only supports software rendering, but there’s a fork I haven’t tried yet which passes OpenGL through to the host for hardware rendering.)
6. Run the Windows version inside Wine with a virtual desktop. (eg. Psychonauts, Space Rangers 2. Doesn’t work with all games because, for reasons I can’t fathom, some games do double-buffering normally (which Wine supports) and triple- or quadruple-buffering (which Wine doesn’t yet support) when you try to run them in a virtual desktop)
7. If it’s something where having a bar down the center of the monitor is a small price to pay for seeing more  (like a strategy game), use export SDL_VIDEO_FULLSCREEN_HEAD=2 to put it on your top-left monitor so it’ll try to span all of them without realizing it. (eg. Revenge of the Titans. Thanks to MakeTechEasier.com for this.)

Once you’ve got that, you may want to simulate fullscreen on a single monitor. The simplest way to do that is to set the window to the same resolution as your monitor, use “Always on Top” to make it cover your panels (taskbar, etc.), and then hide the window border to make it fit the screen. There are two ways to do that:

1. Right-click your window titlebar while the window’s loading, set Always on Top, and then either do it again to hide the window decoration or, if that’s no an option, bind something like WinKey+T to toggle WinDeco and press it. (Tested working in KDE and LXDE/OpenBox)
2. If your window manager allows you to set per-application rules (again, tested working with KDE and LXDE/OpenBox), you can automate this. See your window manager’s documentation for details. (I also use this to make Minecraft start maximized)

One more tip: With games like Trine and Aquaria which capture the mouse, you can toggle the grab with Ctrl+G… useful in Trine for switching back and forth between the game and a walkthrough to get those last few experience vials that you literally can’t find without being told about them.

Update: One or both of these may also help with some games. (Thanks to the Torchlight README.linux for clueing me in)

export SDL_VIDEO_X11_XINERAMA=0
export SDL_VIDEO_X11_XRANDR=0

As much as I love the concept of cheap branching and revision control, I’m a bit of a “code first, ask questions later” kind of guy. Most of my best ideas only come to me once I’m elbow-deep in code and they tend to arrive in bits small enough to make planning my branching and committing impossible.

For this reason, I get a lot of use out of git commands which help me to code first and then sort it out later. Here are my favorites:

IMPORTANT: None of these should be used on commits which have already been shared. Clean up your repository, then “git push”. Eagerness to push is one bad habit you’ll just have to break the hard way.

Temporarily get rid of uncommitted changes

git stash
[do your thing]
git stash pop

The manpage gives some examples for where this can be helpful. The most obvious is “boss interrupts you demanding a bugfix immediately”.

Use a GUI to stage and commit only certain lines

git gui

I use this to untangle unrelated changes into clean commits after the fact. The “git citool” alias makes it automatically close when you commit.

Add the staged changes to the last commit you made instead of a new one

git commit --amend

…or just use “git gui”.

Merge “oops” commits within the last 12 into what they should have been part of

git rebase -i HEAD~12

…and then move each “oops” commit below its parent and change “pick” to “fixup”.

Interactive rebase is a very powerful function which can also be used to apply arbitrary changes to any commit you haven’t yet shared. For details, check out the “reword”, “edit”, and “exec” commands in the instructions it displays.

Note: Rebase can sometimes get confused, but if you ever find yourself confused by its requests for clarification and just want to change your mind, simply use git rebase --abort

Move the last 8 commits to a new branch

git branch my_new_branch
git reset HEAD~8
git checkout my_new_branch

Use this when you you find yourself thinking “Dammit! This should be a feature branch.” It works by telling git to create a new branch with its HEAD here and then to move the current branch’s HEAD 8 commits into the past.

Move the last 8 commits to an existing branch

git stash
git checkout -b tmp
git rebase --onto right_branch HEAD~8
git checkout right_branch
git merge tmp
git branch -d tmp
git checkout wrong_branch
git reset --hard HEAD~8
git checkout right_branch
git stash pop

This complex string of commands is for when you make some commits, then realize you’re on the wrong branch. I wish I could offer something simpler, but moving a string of commits to a branch that could’ve diverged quite far is a complex task.

Basically, you stash away your uncommitted changes, use a temporary branch to rebase and merge the changes into the new branch, and then remove them from the old branch, and apply the uncommitted changes to the new branch.

Undo a merge and rebase instead after accidentally running “git pull” instead of “git fetch”

This is useful when you want to keep a nice, linear development history, you’ve developed something, you try to push it, it fails, and you respond with git pull rather than git fetch. (I tend to forget to pull before developing when switching machines)

The trick is to use git’s reflog feature (git’s Undo history). If your branch is named mybranch and the remote is origin/mybranchand `git pull` is the last thing that made changes, you can undo it like this:

git stash
git reset --merge mybranch@{1}
git rebase origin/mybranch
git stash pop

(You can omit the git stash lines if you don’t have any uncommitted changes)

This feature isn’t limited to undoing merges either. Use this command to see what else you can feed to git reset:

git reflog show

And so on…

Got a type of “oops” I missed? Tell me so I can update this post.

UPDATE: Justin Hileman has an excellent flowchart which you’ll probably also want to check out.

Until recently, I’d been using WhatIsMyIP.com’s API to fill in the external IP field in my Conky readout, but a few days ago, they started a very silly thing where, for whatever reason, clients have to follow a 301 redirect to the URL they just asked for in order to get the IP. I decided that was excuse enough to write a more direct solution.

Since, recently, I’d learned that it’s possible to muck about in m0n0wall without pulling the CF card (despite the lack of proper SSH), I decided to take m0n0wall’s interfaces readout page, strip out everything that wasn’t necessary to get the WAN IPv4 address, and add an explode() call to separate the IP from the hostmask.

If you want it for your own m0n0wall box, here are the instructions:

1. Grab api_wan_ipaddr4.php from my GitHub Gist.
2. Go to exec.php on your m0n0wall box (http://192.168.1.1/exec.php with the default DHCP configuration)
3. (optional) Type “status_interfaces.php” into the download box and use a tool like diff to verify that I haven’t added anything nefarious.
4. Use the exec.php upload interface to upload api_wan_ipaddr4.php.
5. Run these commands using the exec field:

   mv /tmp/api_wan_ipaddr4.php /usr/local/www
   chmod 755 api_wan_ipaddr4.php

6. Load it in your browser (http://192.168.1.1/api_wan_ipaddr4.php with defaults) to confirm that it’s working.
7. Use wget/curl/etc. with HTTP authentication to retrieve your external IP whenever you want. I use this command for my conky:
   

   curl -s --insecure --anyauth --netrc https://192.168.0.1/api_wan_ipaddr4.php

Whenever I have to set up a Python project, I’m always amazed at how little documentation there is on extending distutils to add new commands or otherwise deal with un-anticipated (and apparently, some anticipated) circumstances. In the absence of an easily found HOWTO or guide, I’ve had to go source-diving… and when I do that, it’s only good manners that I share what I found.

The following questions are things I found myself frequently wondering, but feel free to ask me other questions. I’ll add answers for the “likely to be frequent” ones as time permits.

How do I create a new command for distutils?

As I find myself often forgetting this, I’ve posted a template with explanatory comments as a GitHub Gist.

How do I add my custom command to multiple projects without including it and setting cmdclass in each one?

As far as I know, using only distutils, you can’t. However, setuptools provides a mechanism.

How do I make a custom command fail gracefully if non-optional dependencies aren’t present?

• For dependencies internal to Python (modules, specific module versions, etc.), you can define your command inside a try/except or if block. my template includes an example.
• For external commands, I recommend defining your command inside an if block and using a which function to test for them. (Using an external “which” command is ugly and fragile)

How do I access the attributes I passed to setup() from my custom command?

This was a surprisingly involved thing to figure out. setup() passes its arguments to an instance of distutils.dist.Distribution which then parcels them out to various places. 

The simple explanation is that, if it’s set in setup() and setup.py doesn’t complain about it being unrecognized, your command can access it as an attribute of either self.distribution or self.distribution.metadata. (With the possible exception of it being a command-specific option. I forget how those work)

However, the metadata also offers a comprehensive collection of getter methods which return strings like “UNKNOWN” in place of None, so you’ll probably want to ask PyDoc for details:

pydoc distutils.dist.DistributionMetadata

A practical example of the most common use I’ve had for this is retrieving the list of packages to be installed via self.distribution.packages so a tool like Epydoc or Pylint can be run on them.

What’s the recommended way to output messages?

I’m not sure, but from distutils import log seems to be what’s used internally.

Is there a clean, sane way to bundle resources (eg. custom toolbar icons) with my project

Not really. [1] [2] [3] The approaches linked aren’t pretty, but they’re all I’ve been able to find.

Where do I find new commands?

Given that Python has PyPI, you’d think there would at least be a repository of commands for setuptools. However, aside from the commands that come bundled with their associated programs (nosetests, flakes, build_sphinx, etc.), I haven’t found anything. The wiki mentioned in the next question has a very sparse cookbook though.

There’s really no community documentation for this stuff?

There is, but it only covers some of the questions listed here. One of these days when I’m not feeling so unmotivated, I’ll merge this FAQ into theirs. 

Until then, these sites may help to cover some of the deficiencies:

• Dive Into Python 3 – Chapter 16. Packaging Python Libraries
• StackOverflow – Questions tagged distutils, sorted by frequency

Isn’t anybody working to fix this mess?

Yes, but it’s not going to happen overnight.