Where to hold static information for game logic?
If the logic is fixed, keep it in your code. Maybe you can procedurally generate the dicts on startup. If there is a dynamic component to the logic (something you want to update frequently), a data store might be a better bet, but it sounds like that's not applicable here. Unless the number of combinations runs over the millions, and you'd want to trade speed in favour of a lower memory footprint, stick with putting it in the application itself.
The context for this question is:

A Google App Engine backend for a two-person multiplayer turn-based card game
The game revolves around different combinations of cards giving rise to different scores in the game

Obviously, one would store the state of a game in the GAE datastore, but I'm not sure on the approach for the design of the game logic itself.  It seems I might have two choices:

Store entries in the datastore with a key that is a sorted list of the valid combinations of cards that can be player.  These will then map to the score values.  When a player tries to play a combination of cards, the server-side python will sort the combination appropriately and lookup the key.  If it succeeds, it can do the necessary updates for the score, if it fails then the combination wasn't valid.
Store the valid combinations as a python dictionary written into the server-side code and perform the same lookups as above to test the validity/get the score but without a trip to the datastore.

From a cost point of view (datastore lookups aren't free), option 2 seems like it would be better.  But then there is the performance of the instance itself - will the startup time, processing time, memory usage start to tip me into greater expense?
There's also the code maintanence issue of constructing that Python dictionary, but I can bash together some scripts to help me write the code for that on the infrequently occasions that the logic changes.  I think there will be on the order of 1000 card combinations (that can produce a score) of between 2 and 6 cards if that helps anyone who wants to quantify the problem.
I'm starting out with this design, and the summary of the above is whether it is sensible to store the static logic of this kind of game in the datastore, or simply keep it as part of the CPU bound logic?  What are the pros and cons of both approaches?