You just have to run python -m compileall again. It will overwrite older .pyc files. You can pass it the -f switch to force rebuild even if timestamps are up to date (as per the documentation).

Go to the directory of the .py file and run python -m compileall ..

If your files are structures as below use reload(module) to recompile each time you refresh the toolbox in ArcMap.

main.pyt:

import arcpy
import tool_file
reload(tool_file)
from tool_file import test_tool

class Toolbox(object):
    def __init__(self):
        """Define the toolbox (the name of the toolbox is the name of the
        .pyt file)."""
        self.label = "ToolboxLabel"
        self.alias = "tool_box_alias"

        # List of tool classes associated with this toolbox
        self.tools = [test_tool]

tool_file.py:

import arcpy


class test_tool(object):
    def __init__(self):
        """Define the tool (tool name is the name of the class)."""
        self.label = "test_tool"
        self.description = "tool to test"
        self.canRunInBackground = False


    def getParameterInfo(self):
        """Define parameter definitions"""
        params = None


        return params


    def isLicensed(self):
        """Set whether tool is licensed to execute."""
        return True


    def updateParameters(self, parameters):
        """Modify the values and properties of parameters before internal
        validation is performed.    This method is called whenever a parameter
        has been changed. in the window interface"""

        return


    def updateMessages(self, parameters):
        """Modify the messages created by internal validation for each tool
        parameter.    This method is called after internal validation."""

        # *************************************************************************
        # change this message to test whether changes are being reflected correctly 
        # when you refresh in arcmap
        arcpy.AddMessage('hello world')
        # *************************************************************************
        return


    def execute(self, parameters, messages):
        return

You can use the builtin reload function in python to automatically reload your module. What you can do is something like this:

import mymodule

def hook():
    reload(mymodule)
    mymodule.myfunction()

where hook() is what's called by ArcMap and mymodule is the module you're editing between invocations. You may have to edit sys.path to include the path of the module you're editing so that import mymodule does not fail. Or include the directory in site-packages (maybe using python setup.py develop).

I would suggest that whatever problem you have it will not be solved by recompiling the python version. Python 2.7.x is standard on Ubuntu 12.04 and is used by many Ubuntu utils, I would not advise trying to install a recompiled version over it.

As gertvdijk suggests, a more specific description of the problem may help.

Can you try starting the python interpreter by opening a terminal window and typing:

$python 
Python 2.7.4 (default, Apr 19 2013, 18:28:01) 
[GCC 4.7.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

When the intepreter starts, then type

>>>import sqlite3

If you get no response (other than a newline here) then python has access to sqlite module.

If you get some error output, post it here, and we can take it from there.

Rob

I've had a lot of experience running a compiled regex 1000s of times versus compiling on-the-fly, and have not noticed any perceivable difference. Obviously, this is anecdotal, and certainly not a great argument against compiling, but I've found the difference to be negligible.

EDIT: After a quick glance at the actual Python 2.5 library code, I see that Python internally compiles AND CACHES regexes whenever you use them anyway (including calls to re.match()), so you're really only changing WHEN the regex gets compiled, and shouldn't be saving much time at all - only the time it takes to check the cache (a key lookup on an internal dict type).

From module re.py (comments are mine):

def match(pattern, string, flags=0):
    return _compile(pattern, flags).match(string)

def _compile(*key):

    # Does cache check at top of function
    cachekey = (type(key[0]),) + key
    p = _cache.get(cachekey)
    if p is not None: return p

    # ...
    # Does actual compilation on cache miss
    # ...

    # Caches compiled regex
    if len(_cache) >= _MAXCACHE:
        _cache.clear()
    _cache[cachekey] = p
    return p

I still often pre-compile regular expressions, but only to bind them to a nice, reusable name, not for any expected performance gain.