Updage cgpm to Python 3.

pythenv.sh

@@ -4,8 +4,8 @@ set -Ceu
 
 : ${PYTHON:=python}
 root=`cd -- "$(dirname -- "$0")" && pwd`
-platform=`"${PYTHON}" -c 'import distutils.util as u; print u.get_platform()'`
-version=`"${PYTHON}" -c 'import sys; print sys.version[0:3]'`
+platform=`"${PYTHON}" -c 'import distutils.util as u; print(u.get_platform())'`
+version=`"${PYTHON}" -c 'import sys; print(sys.version[0:3])'`
 
 # The lib directory varies depending on
 #

setup.py

@@ -48,6 +48,7 @@ def get_version():
     # - verpart     v1.1.2
     # - revpart     2
     # - localpart   gb92bef6[-dirty]
+    # FIXME: This command fails.
     desc = subprocess.check_output([
         'git', 'describe', '--dirty', '--long', '--match', 'v*',
     ])
@@ -83,14 +84,14 @@ def get_version():
 
 def write_version_py(path):
     try:
-        with open(path, 'rb') as f:
+        with open(path, 'rt') as f:
             version_old = f.read()
     except IOError:
         version_old = None
     version_new = '__version__ = %r\n' % (full_version,)
     if version_old != version_new:
-        print 'writing %s' % (path,)
-        with open(path, 'wb') as f:
+        print('writing %s' % (path,))
+        with open(path, 'wt') as f:
             f.write(version_new)
 
 def readme_contents():
@@ -99,7 +100,7 @@ def readme_contents():
         os.path.abspath(os.path.dirname(__file__)),
         'README.md')
     with open(readme_path) as readme_file:
-        return unicode(readme_file.read(), 'UTF-8')
+        return str(readme_file.read())
 
 class local_build_py(build_py):
     def run(self):

src/crosscat/loomcat.py

@@ -40,7 +40,7 @@
 
 def _generate_column_names(state):
     """Returns list of dummy names for the outputs of `state`."""
-    return [unicode('c%05d') % (i,) for i in state.outputs]
+    return ['c%05d' % (i,) for i in state.outputs]
 
 
 def _generate_loom_stattypes(state):
@@ -126,13 +126,13 @@ def _retrieve_row_partitions(path, sample):
     assign_in = os.path.join(
         path, 'samples', 'sample.%d' % (sample,), 'assign.pbs.gz')
     assignments = {
-        a.rowid: [a.groupids(k) for k in xrange(num_kinds)]
+        a.rowid: [a.groupids(k) for k in range(num_kinds)]
         for a in assignment_stream_load(assign_in)
     }
     rowids = sorted(assignments)
     return {
         k: [assignments[rowid][k] for rowid in rowids]
-        for k in xrange(num_kinds)
+        for k in range(num_kinds)
     }
 
 
@@ -328,7 +328,7 @@ def transition_engine(
     # Update the engine and save the engine.
     args = [
         (engine.states[i], engine.states[i]._loom_path['results'], i)
-        for i in xrange(engine.num_states())
+        for i in range(engine.num_states())
     ]
     engine.states = parallel_map(_update_state_mp, args)
 

src/crosscat/lovecat.py

@@ -35,25 +35,22 @@ def _crosscat_M_c(state):
 
     def create_metadata_numerical():
         return {
-            unicode('modeltype'): unicode('normal_inverse_gamma'),
-            unicode('value_to_code'): {},
-            unicode('code_to_value'): {},
+            'modeltype': 'normal_inverse_gamma',
+            'value_to_code': {},
+            'code_to_value': {},
         }
     def create_metadata_categorical(col, k):
         categories = [v for v in sorted(set(T[col])) if not np.isnan(v)]
         assert all(0 <= c < k for c in categories)
-        codes = [unicode('%d') % (c,) for c in categories]
-        ncodes = range(len(codes))
+        codes = ['%d' % (c,) for c in categories]
+        ncodes = list(range(len(codes)))
         return {
-            unicode('modeltype'):
-                unicode('symmetric_dirichlet_discrete'),
-            unicode('value_to_code'):
-                dict(zip(map(unicode, ncodes), codes)),
-            unicode('code_to_value'):
-                dict(zip(codes, ncodes)),
+            'modeltype': 'symmetric_dirichlet_discrete',
+            'value_to_code': dict(zip(map(str, ncodes), codes)),
+            'code_to_value': dict(zip(codes, ncodes)),
         }
 
-    column_names = [unicode('c%d') % (i,) for i in outputs]
+    column_names = ['c%d' % (i,) for i in outputs]
     # Convert all numerical datatypes to normal for lovecat.
     column_metadata = [
         create_metadata_numerical() if cctype != 'categorical' else\
@@ -62,12 +59,9 @@ def create_metadata_categorical(col, k):
     ]
 
     return {
-        unicode('name_to_idx'):
-            dict(zip(column_names, range(ncols))),
-        unicode('idx_to_name'):
-            dict(zip(map(unicode, range(ncols)), column_names)),
-        unicode('column_metadata'):
-            column_metadata,
+        'name_to_idx': dict(zip(column_names, range(ncols))),
+        'idx_to_name': dict(zip(map(str, range(ncols)), column_names)),
+        'column_metadata': column_metadata,
     }
 
 def _crosscat_T(state, M_c):
@@ -81,8 +75,8 @@ def crosscat_value_to_code(val, col):
         # need to do code->value.
         lookup = M_c['column_metadata'][col]['code_to_value']
         if lookup:
-            assert unicode(int(val)) in lookup
-            return float(lookup[unicode(int(val))])
+            assert str(int(val)) in lookup
+            return float(lookup[str(int(val))])
         else:
             return val
     ordering = state.outputs
@@ -127,21 +121,21 @@ def _crosscat_X_L(state, M_c, X_D):
     def column_hypers_numerical(index, hypers):
         assert state.cctypes()[index] != 'categorical'
         return {
-            unicode('fixed'): 0.0,
-            unicode('mu'): hypers['m'],
-            unicode('nu'): hypers['nu'],
-            unicode('r'): hypers['r'],
-            unicode('s'): hypers['s'],
+            'fixed': 0.0,
+            'mu': hypers['m'],
+            'nu': hypers['nu'],
+            'r': hypers['r'],
+            's': hypers['s'],
         }
 
     def column_hypers_categorical(index, hypers):
         assert state.cctypes()[index] == 'categorical'
         K = len(M_c['column_metadata'][index]['code_to_value'])
         assert K > 0
         return {
-            unicode('fixed'): 0.0,
-            unicode('dirichlet_alpha'): hypers['alpha'],
-            unicode('K'): K
+            'fixed': 0.0,
+            'dirichlet_alpha': hypers['alpha'],
+            'K': K
         }
 
     # Retrieve the column_hypers.
@@ -162,9 +156,9 @@ def column_hypers_categorical(index, hypers):
     counts = list(np.bincount(views_remapped))
     assert 0 not in counts
     column_partition = {
-        unicode('assignments'): views_remapped,
-        unicode('counts'): counts,
-        unicode('hypers'): {unicode('alpha'): state.alpha()}
+        'assignments': views_remapped,
+        'counts': counts,
+        'hypers': {'alpha': state.alpha()}
     }
 
     # -- Generates X_L['view_state'] --
@@ -174,25 +168,23 @@ def view_state(v):
         # Generate X_L['view_state'][v]['column_component_suffstats']
         numcategories = len(set(row_partition))
         column_component_suffstats = [
-            [{} for c in xrange(numcategories)]
+            [{} for c in range(numcategories)]
             for d in view.dims]
 
         # Generate X_L['view_state'][v]['column_names']
         column_names = \
-            [unicode('c%d' % (o,)) for o in view.outputs[1:]]
+            ['c%d' % (o,) for o in view.outputs[1:]]
 
         # Generate X_L['view_state'][v]['row_partition_model']
         counts = list(np.bincount(row_partition))
         assert 0 not in counts
 
         return {
-            unicode('column_component_suffstats'):
-                column_component_suffstats,
-            unicode('column_names'):
-                column_names,
-            unicode('row_partition_model'): {
-                unicode('counts'): counts,
-                unicode('hypers'): {unicode('alpha'): view.alpha()}
+            'column_component_suffstats': column_component_suffstats,
+            'column_names': column_names,
+            'row_partition_model': {
+                    'counts': counts,
+                    'hypers': {'alpha': view.alpha()}
             }
         }
 
@@ -212,14 +204,14 @@ def view_state(v):
         from crosscat.utils.general_utils import get_scc_from_tuples
         col_ensure['independent'] = {
             str(column) : list(block) for
-            column, block in get_scc_from_tuples(state.Ci).iteritems()
+            column, block in get_scc_from_tuples(state.Ci).items()
         }
 
     return {
-        unicode('column_hypers'): column_hypers,
-        unicode('column_partition'): column_partition,
-        unicode('view_state'): view_states,
-        unicode('col_ensure'): col_ensure
+        'column_hypers': column_hypers,
+        'column_partition': column_partition,
+        'view_state': view_states,
+        'col_ensure': col_ensure
     }
 
 
@@ -231,7 +223,7 @@ def _check_model_type(i):
         reference = 'normal_inverse_gamma' if state.cctypes()[i] == 'normal'\
             else 'symmetric_dirichlet_discrete'
         return M_c['column_metadata'][i]['modeltype'] == reference
-    assert all(_check_model_type(i) for i in xrange(len(state.cctypes())))
+    assert all(_check_model_type(i) for i in range(len(state.cctypes())))
     # Perform checking on X_D.
     assert all(len(partition)==state.n_rows() for partition in X_D)
     assert len(X_D) == len(X_L['view_state'])
@@ -240,18 +232,18 @@ def _check_model_type(i):
 
     # Update the global state alpha.
     state.crp.set_hypers(
-        {'alpha': X_L['column_partition']['hypers']['alpha']}
+        {'alpha': X_L['column_partition']['hypers'][b'alpha']}
     )
 
-    assert state.alpha() == X_L['column_partition']['hypers']['alpha']
+    assert state.alpha() == X_L['column_partition']['hypers'][b'alpha']
     assert state.crp.clusters[0].alpha ==\
-        X_L['column_partition']['hypers']['alpha']
+        X_L['column_partition']['hypers'][b'alpha']
 
     # Create the new views.
     offset = max(state.views) + 1
     new_views = []
-    for v in xrange(len(X_D)):
-        alpha = X_L['view_state'][v]['row_partition_model']['hypers']['alpha']
+    for v in range(len(X_D)):
+        alpha = X_L['view_state'][v]['row_partition_model']['hypers'][b'alpha']
         index = v + offset
 
         assert index not in state.views
@@ -317,8 +309,8 @@ def convert_column_partition(assignments):
 
 def _progress(n_steps, max_time, step_idx, elapsed_secs, end=None):
     if end:
-        print '\rCompleted: %d iterations in %f seconds.' %\
-            (step_idx, elapsed_secs)
+        print('\rCompleted: %d iterations in %f seconds.' %
+              (step_idx, elapsed_secs))
     else:
         p_seconds = elapsed_secs / max_time if max_time != -1 else 0
         p_iters = float(step_idx) / n_steps

src/crosscat/sampling.py

@@ -103,7 +103,7 @@ def _logpdf_row(view, targets, cluster):
     """Return joint density of the targets in a fixed cluster."""
     return sum(
         view.dims[c].logpdf(None, {c:x}, None, {view.outputs[0]: cluster})
-        for c, x in targets.iteritems()
+        for c, x in targets.items()
     )