# Paste Style Guide

Generally you should follow the recommendations in PEP 8, the Python Style Guide. Some things to take particular note of:

- No tabs. Not anywhere. Always indent with 4 spaces.

- I don’t stress too much on line length. But try to break lines up by grouping with parenthesis instead of with backslashes (if you can). Do asserts like:

      assert some_condition(a, b), (
          "Some condition failed, %r isn't right!" % a)

- But if you are having problems with line length, maybe you should just break the expression up into multiple statements.

- Blank lines between methods, unless they are very small and closely bound to each other.

- Don’t use the form `condition and trueValue or falseValue`. Break it out and use a variable.

- I (Ian Bicking) am very picky about whitespace. There’s one and only one right way to do it. Good examples:

      short = 3
      longerVar = 4

      if x == 4:
          do stuff

      func(arg1='a', arg2='b')
      func((a + b)*10)

  Bad examples:

      short    =3
      longerVar=4

      if x==4: do stuff

      func(arg1 = 'a', arg2 = 'b')
      func(a,b)
      func( a, b )
      [ 1, 2, 3 ]

  If the whitespace isn’t right, it’ll annoy me and I’ll feel a need to fix it. Really, this whitespace stuff shouldn’t be that controversial should it? Some particular points that I feel strongly about:

  - No space after a function name (bad: `func (arg)`).

  - No space after or before a parenthesis (bad: `func( arg )`).

  - Always one space after a comma (bad: `func(a,b)`).

- Use `@@` to mark something that is suboptimal, or where you have a concern that it’s not right. Try to also date it and put your username there.

- Docstrings are good. They should look like:

      class AClass(object):
          """
          doc string...
          """

  Don’t use single quotes (‘’’) – they tend to cause problems in Emacs. Don’t bother trying make the string less vertically compact.

- Comments go right before the thing they are commenting on.

- Methods never, ever, ever start with capital letters. Generally only classes are capitalized. But definitely never methods.

- Use `cls` to refer to a class. Use `meta` to refer to a metaclass (which also happens to be a class, but calling a metaclass `cls` will be confusing).

- Use `isinstance` instead of comparing types. E.g.:

      if isinstance(var, str): ...
      # Bad:
      if type(var) is StringType: ...

- Never, ever use two leading underscores. This is annoyingly private. If name clashes are a concern, use explicit name mangling instead (e.g., `_MyThing_blahblah`). This is essentially the same thing as double-underscore, only it’s transparent where double underscore obscures.

- Module names should be unique in the package. Subpackages shouldn’t share module names with sibling or parent packages. Sadly this isn’t possible for `__init__.py`, but it’s otherwise easy enough.

- Module names should be all lower case, and probably have no underscores (smushedwords).