Add protobuf format support to labours.py

cmd/hercules/main.go

@@ -294,21 +294,21 @@ func serializeResults(
 	}
 
 	if withFiles {
-		message.BurndownFile = make([]*pb.BurndownSparseMatrix, len(burndownResults.FileHistories))
+		message.BurndownFiles = make([]*pb.BurndownSparseMatrix, len(burndownResults.FileHistories))
 		keys := sortedKeys(burndownResults.FileHistories)
 		i := 0
 		for _, key := range keys {
-			message.BurndownFile[i] = pb.ToBurndownSparseMatrix(
+			message.BurndownFiles[i] = pb.ToBurndownSparseMatrix(
 				burndownResults.FileHistories[key], key)
 			i++
 		}
 	}
 
 	if withPeople {
-		message.BurndownDeveloper = make(
+		message.BurndownDevelopers = make(
 		  []*pb.BurndownSparseMatrix, len(burndownResults.PeopleHistories))
 		for key, val := range burndownResults.PeopleHistories {
-			message.BurndownDeveloper[key] = pb.ToBurndownSparseMatrix(val, reversePeopleDict[key])
+			message.BurndownDevelopers[key] = pb.ToBurndownSparseMatrix(val, reversePeopleDict[key])
 		}
 		message.DevelopersInteraction = pb.DenseToCompressedSparseRowMatrix(
 			burndownResults.PeopleMatrix)
@@ -324,7 +324,7 @@ func serializeResults(
 			Matrix: pb.MapToCompressedSparseRowMatrix(couplesResult.PeopleMatrix),
 		}
 		message.TouchedFiles = &pb.DeveloperTouchedFiles{
-      Developer: make([]*pb.TouchedFiles, len(reversePeopleDict)),
+      Developers: make([]*pb.TouchedFiles, len(reversePeopleDict)),
 		}
 		for key := range reversePeopleDict {
 			files := couplesResult.PeopleFiles[key]
@@ -332,8 +332,8 @@ func serializeResults(
 			for i, f := range files {
 				int32Files[i] = int32(f)
 			}
-			message.TouchedFiles.Developer[key] = &pb.TouchedFiles{
-				File: int32Files,
+			message.TouchedFiles.Developers[key] = &pb.TouchedFiles{
+				Files: int32Files,
 			}
 		}
 	}

labours.py

@@ -107,7 +107,6 @@ class YamlReader(Reader):
             print("\nInvalid unicode in the input: %s\nPlease filter it through "
                   "fix_yaml_unicode.py" % e)
             sys.exit(1)
-        print("done")
         self.data = data
 
     def get_name(self):
@@ -161,7 +160,58 @@ class YamlReader(Reader):
 
 class ProtobufReader(Reader):
     def read(self, file):
-        pass
+        from pb.pb_pb2 import AnalysisResults
+        self.data = AnalysisResults()
+        if file != "-":
+            with open(file, "rb") as fin:
+                self.data.ParseFromString(fin.read())
+        else:
+            self.data.ParseFromString(sys.stdin.buffer.read())
+
+    def get_name(self):
+        return self.data.header.repository
+
+    def get_header(self):
+        header = self.data.header
+        return header.begin_unix_time, header.end_unix_time, \
+            header.sampling, header.granularity
+
+    def get_project_burndown(self):
+        return self._parse_burndown_matrix(self.data.burndown_project)
+
+    def get_files_burndown(self):
+        return [self._parse_burndown_matrix(i) for i in self.data.burndown_files]
+
+    def get_people_burndown(self):
+        return [self._parse_burndown_matrix(i) for i in self.data.burndown_developers]
+
+    def get_ownership_burndown(self):
+        people = self.get_people_burndown()
+        return [p[0] for p in people], {p[0]: p[1].T for p in people}
+
+    def get_people_interaction(self):
+        return [i.name for i in self.data.burndown_developers], \
+            self._parse_sparse_matrix(self.data.developers_interaction).toarray()
+
+    def get_files_coocc(self):
+        node = self.data.file_couples
+        return list(node.index), self._parse_sparse_matrix(node.matrix)
+
+    def get_people_coocc(self):
+        node = self.data.developer_couples
+        return list(node.index), self._parse_sparse_matrix(node.matrix)
+
+    def _parse_burndown_matrix(self, matrix):
+        dense = numpy.zeros((matrix.number_of_rows, matrix.number_of_columns), dtype=int)
+        for y, row in enumerate(matrix.rows):
+            for x, col in enumerate(row.columns):
+                dense[y, x] = col
+        return matrix.name, dense.T
+
+    def _parse_sparse_matrix(self, matrix):
+        from scipy.sparse import csr_matrix
+        return csr_matrix((list(matrix.data), list(matrix.indices), list(matrix.indptr)),
+                          shape=(matrix.number_of_rows, matrix.number_of_columns))
 
 
 READERS = {"yaml": YamlReader, "pb": ProtobufReader}
@@ -172,6 +222,7 @@ def read_input(args):
     sys.stdout.flush()
     reader = READERS[args.input_format]()
     reader.read(args.input)
+    print("done")
     return reader
 
 

pb/pb.pb.go

@@ -108,7 +108,7 @@ func (m *Metadata) GetSampling() int32 {
 type BurndownSparseMatrixRow struct {
 	// the first `len(column)` elements are stored,
 	// the rest `number_of_columns - len(column)` values are zeros
-	Column []uint32 `protobuf:"varint,1,rep,packed,name=column" json:"column,omitempty"`
+	Columns []uint32 `protobuf:"varint,1,rep,packed,name=columns" json:"columns,omitempty"`
 }
 
 func (m *BurndownSparseMatrixRow) Reset()                    { *m = BurndownSparseMatrixRow{} }
@@ -116,9 +116,9 @@ func (m *BurndownSparseMatrixRow) String() string            { return proto.Comp
 func (*BurndownSparseMatrixRow) ProtoMessage()               {}
 func (*BurndownSparseMatrixRow) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{1} }
 
-func (m *BurndownSparseMatrixRow) GetColumn() []uint32 {
+func (m *BurndownSparseMatrixRow) GetColumns() []uint32 {
 	if m != nil {
-		return m.Column
+		return m.Columns
 	}
 	return nil
 }
@@ -128,7 +128,7 @@ type BurndownSparseMatrix struct {
 	NumberOfRows    int32  `protobuf:"varint,2,opt,name=number_of_rows,json=numberOfRows,proto3" json:"number_of_rows,omitempty"`
 	NumberOfColumns int32  `protobuf:"varint,3,opt,name=number_of_columns,json=numberOfColumns,proto3" json:"number_of_columns,omitempty"`
 	// `len(row)` matches `number_of_rows`
-	Row []*BurndownSparseMatrixRow `protobuf:"bytes,4,rep,name=row" json:"row,omitempty"`
+	Rows []*BurndownSparseMatrixRow `protobuf:"bytes,4,rep,name=rows" json:"rows,omitempty"`
 }
 
 func (m *BurndownSparseMatrix) Reset()                    { *m = BurndownSparseMatrix{} }
@@ -157,9 +157,9 @@ func (m *BurndownSparseMatrix) GetNumberOfColumns() int32 {
 	return 0
 }
 
-func (m *BurndownSparseMatrix) GetRow() []*BurndownSparseMatrixRow {
+func (m *BurndownSparseMatrix) GetRows() []*BurndownSparseMatrixRow {
 	if m != nil {
-		return m.Row
+		return m.Rows
 	}
 	return nil
 }
@@ -240,7 +240,7 @@ func (m *Couples) GetMatrix() *CompressedSparseRowMatrix {
 }
 
 type TouchedFiles struct {
-	File []int32 `protobuf:"varint,1,rep,packed,name=file" json:"file,omitempty"`
+	Files []int32 `protobuf:"varint,1,rep,packed,name=files" json:"files,omitempty"`
 }
 
 func (m *TouchedFiles) Reset()                    { *m = TouchedFiles{} }
@@ -248,16 +248,16 @@ func (m *TouchedFiles) String() string            { return proto.CompactTextStri
 func (*TouchedFiles) ProtoMessage()               {}
 func (*TouchedFiles) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{5} }
 
-func (m *TouchedFiles) GetFile() []int32 {
+func (m *TouchedFiles) GetFiles() []int32 {
 	if m != nil {
-		return m.File
+		return m.Files
 	}
 	return nil
 }
 
 type DeveloperTouchedFiles struct {
 	// order corresponds to `developer_couples::index`
-	Developer []*TouchedFiles `protobuf:"bytes,1,rep,name=developer" json:"developer,omitempty"`
+	Developers []*TouchedFiles `protobuf:"bytes,1,rep,name=developers" json:"developers,omitempty"`
 }
 
 func (m *DeveloperTouchedFiles) Reset()                    { *m = DeveloperTouchedFiles{} }
@@ -265,9 +265,9 @@ func (m *DeveloperTouchedFiles) String() string            { return proto.Compac
 func (*DeveloperTouchedFiles) ProtoMessage()               {}
 func (*DeveloperTouchedFiles) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{6} }
 
-func (m *DeveloperTouchedFiles) GetDeveloper() []*TouchedFiles {
+func (m *DeveloperTouchedFiles) GetDevelopers() []*TouchedFiles {
 	if m != nil {
-		return m.Developer
+		return m.Developers
 	}
 	return nil
 }
@@ -277,9 +277,9 @@ type AnalysisResults struct {
 	Header          *Metadata             `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
 	BurndownProject *BurndownSparseMatrix `protobuf:"bytes,2,opt,name=burndown_project,json=burndownProject" json:"burndown_project,omitempty"`
 	// this is included if `-files` was specified
-	BurndownFile []*BurndownSparseMatrix `protobuf:"bytes,3,rep,name=burndown_file,json=burndownFile" json:"burndown_file,omitempty"`
+	BurndownFiles []*BurndownSparseMatrix `protobuf:"bytes,3,rep,name=burndown_files,json=burndownFiles" json:"burndown_files,omitempty"`
 	// these two are included if `-people` was specified
-	BurndownDeveloper []*BurndownSparseMatrix `protobuf:"bytes,4,rep,name=burndown_developer,json=burndownDeveloper" json:"burndown_developer,omitempty"`
+	BurndownDevelopers []*BurndownSparseMatrix `protobuf:"bytes,4,rep,name=burndown_developers,json=burndownDevelopers" json:"burndown_developers,omitempty"`
 	// rows and cols order correspond to `burndown_developer`
 	DevelopersInteraction *CompressedSparseRowMatrix `protobuf:"bytes,5,opt,name=developers_interaction,json=developersInteraction" json:"developers_interaction,omitempty"`
 	// these three are included if `-couples` was specified
@@ -307,16 +307,16 @@ func (m *AnalysisResults) GetBurndownProject() *BurndownSparseMatrix {
 	return nil
 }
 
-func (m *AnalysisResults) GetBurndownFile() []*BurndownSparseMatrix {
+func (m *AnalysisResults) GetBurndownFiles() []*BurndownSparseMatrix {
 	if m != nil {
-		return m.BurndownFile
+		return m.BurndownFiles
 	}
 	return nil
 }
 
-func (m *AnalysisResults) GetBurndownDeveloper() []*BurndownSparseMatrix {
+func (m *AnalysisResults) GetBurndownDevelopers() []*BurndownSparseMatrix {
 	if m != nil {
-		return m.BurndownDeveloper
+		return m.BurndownDevelopers
 	}
 	return nil
 }
@@ -363,45 +363,45 @@ func init() {
 func init() { proto.RegisterFile("pb/pb.proto", fileDescriptorPb) }
 
 var fileDescriptorPb = []byte{
-	// 639 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0x4d, 0x6f, 0xd3, 0x4c,
-	0x10, 0x96, 0x6b, 0x3b, 0x1f, 0xe3, 0xe4, 0x4d, 0xbb, 0x6a, 0xfb, 0xfa, 0xed, 0xe1, 0x55, 0xb0,
-	0x10, 0x8a, 0x5a, 0xc9, 0x88, 0x20, 0x2e, 0x70, 0x01, 0x5a, 0x21, 0x71, 0xa8, 0x80, 0x6d, 0x39,
-	0x5b, 0x8e, 0x3d, 0x6d, 0x17, 0xd9, 0xbb, 0xd6, 0xee, 0xba, 0x49, 0xff, 0x11, 0x77, 0xfe, 0x14,
-	0x07, 0x7e, 0x04, 0xf2, 0xfa, 0x23, 0x01, 0x52, 0xe0, 0xe6, 0x99, 0x79, 0x9e, 0xf1, 0xf3, 0xcc,
-	0x8c, 0x0d, 0x5e, 0xb1, 0x78, 0x5c, 0x2c, 0xc2, 0x42, 0x0a, 0x2d, 0x82, 0xaf, 0x16, 0x0c, 0xce,
-	0x51, 0xc7, 0x69, 0xac, 0x63, 0xe2, 0x43, 0xff, 0x16, 0xa5, 0x62, 0x82, 0xfb, 0xd6, 0xd4, 0x9a,
-	0xb9, 0xb4, 0x0d, 0xab, 0x4a, 0x92, 0xa7, 0x19, 0xe3, 0xe8, 0xef, 0x4c, 0xad, 0xd9, 0x90, 0xb6,
-	0x21, 0xf9, 0x1f, 0x40, 0x62, 0x21, 0x14, 0xd3, 0x42, 0xde, 0xf9, 0xb6, 0x29, 0x6e, 0x64, 0xc8,
-	0x23, 0x98, 0x2c, 0xf0, 0x9a, 0xf1, 0xa8, 0xe4, 0x6c, 0x15, 0x69, 0x96, 0xa3, 0xef, 0x4c, 0xad,
-	0x99, 0x4d, 0xc7, 0x26, 0xfd, 0x91, 0xb3, 0xd5, 0x25, 0xcb, 0x91, 0x04, 0x30, 0x46, 0x9e, 0x6e,
-	0xa0, 0x5c, 0x83, 0xf2, 0x90, 0xa7, 0x1d, 0x66, 0x0a, 0xde, 0xb5, 0x8c, 0x79, 0x99, 0xc5, 0x92,
-	0xe9, 0x3b, 0xbf, 0x67, 0x34, 0x6e, 0xa6, 0xc8, 0x11, 0x0c, 0x54, 0x9c, 0x17, 0x19, 0xe3, 0xd7,
-	0x7e, 0xdf, 0x94, 0xbb, 0x38, 0x78, 0x02, 0xff, 0xbe, 0x2e, 0x25, 0x4f, 0xc5, 0x92, 0x5f, 0x14,
-	0xb1, 0x54, 0x78, 0x1e, 0x6b, 0xc9, 0x56, 0x54, 0x2c, 0xc9, 0x21, 0xf4, 0x12, 0x91, 0x95, 0x79,
-	0xe5, 0xdb, 0x9e, 0x8d, 0x69, 0x13, 0x05, 0x9f, 0x2d, 0xd8, 0xdf, 0xc6, 0x21, 0x04, 0x1c, 0x1e,
-	0xe7, 0x68, 0xc6, 0x34, 0xa4, 0xe6, 0x99, 0x3c, 0x84, 0x7f, 0x78, 0x99, 0x2f, 0x50, 0x46, 0xe2,
-	0x2a, 0x92, 0x62, 0xa9, 0xcc, 0xa8, 0x5c, 0x3a, 0xaa, 0xb3, 0xef, 0xae, 0xa8, 0x58, 0x2a, 0x72,
-	0x0c, 0x7b, 0x6b, 0x54, 0xfd, 0x1a, 0x65, 0xc6, 0xe6, 0xd2, 0x49, 0x0b, 0x3c, 0xad, 0xd3, 0xe4,
-	0x18, 0x6c, 0x29, 0x96, 0xbe, 0x33, 0xb5, 0x67, 0xde, 0xdc, 0x0f, 0xef, 0x51, 0x4f, 0x2b, 0x50,
-	0xf0, 0xc5, 0x82, 0xff, 0x4e, 0x45, 0x5e, 0x48, 0x54, 0x0a, 0xd3, 0x1a, 0x42, 0xc5, 0xb2, 0xd1,
-	0xfb, 0xab, 0x36, 0xeb, 0x6f, 0xb5, 0xed, 0x6c, 0xd7, 0x46, 0xc0, 0xa9, 0x6e, 0xc6, 0xb7, 0xa7,
-	0xf6, 0xcc, 0xa6, 0x4e, 0x7b, 0x3f, 0x8c, 0xa7, 0x2c, 0x41, 0x65, 0x34, 0xbb, 0xb4, 0x0d, 0xab,
-	0x01, 0x33, 0x9e, 0x16, 0x5a, 0xfa, 0xae, 0xc1, 0x37, 0x51, 0x70, 0x01, 0xfd, 0x53, 0x51, 0x16,
-	0x19, 0x2a, 0xb2, 0x0f, 0x2e, 0xe3, 0x29, 0xae, 0xcc, 0x0a, 0x86, 0xb4, 0x0e, 0xc8, 0x1c, 0x7a,
-	0xb9, 0xb1, 0x60, 0x74, 0x78, 0xf3, 0xa3, 0xf0, 0x5e, 0x93, 0xb4, 0x41, 0x06, 0x01, 0x8c, 0x2e,
-	0x45, 0x99, 0xdc, 0x60, 0xfa, 0x86, 0x55, 0x9d, 0x09, 0x38, 0x57, 0x2c, 0x43, 0xd3, 0xd8, 0xa5,
-	0xe6, 0x39, 0x38, 0x83, 0x83, 0x33, 0xbc, 0xc5, 0x4c, 0x14, 0x28, 0x7f, 0x00, 0x9f, 0xc0, 0x30,
-	0x6d, 0x0b, 0x86, 0xe1, 0xcd, 0xc7, 0xe1, 0x26, 0x82, 0xae, 0xeb, 0xc1, 0x37, 0x1b, 0x26, 0xaf,
-	0x78, 0x9c, 0xdd, 0x29, 0xa6, 0x28, 0xaa, 0x32, 0xd3, 0x8a, 0x3c, 0x80, 0xde, 0x0d, 0xc6, 0xa9,
-	0x61, 0x57, 0x8a, 0x87, 0x61, 0xfb, 0x7d, 0xd1, 0xa6, 0x40, 0x5e, 0xc2, 0xee, 0xa2, 0xd9, 0x65,
-	0x54, 0x48, 0xf1, 0x09, 0x13, 0xdd, 0xd8, 0x3b, 0xd8, 0xbe, 0xe4, 0x49, 0x0b, 0x7f, 0x5f, 0xa3,
-	0xc9, 0x73, 0x18, 0x77, 0x1d, 0x8c, 0x37, 0xdb, 0x28, 0xbd, 0x87, 0x3e, 0x6a, 0xb1, 0x95, 0x01,
-	0x72, 0x06, 0xa4, 0xe3, 0xae, 0xad, 0x3a, 0xbf, 0x6b, 0xb0, 0xd7, 0x12, 0xba, 0x99, 0x91, 0x0f,
-	0x70, 0xd8, 0x91, 0x55, 0xc4, 0xb8, 0x46, 0x19, 0x27, 0xba, 0xfa, 0x75, 0xb8, 0x7f, 0x5c, 0xd4,
-	0xc1, 0x9a, 0xf9, 0x76, 0x4d, 0x24, 0x27, 0x30, 0xaa, 0xbc, 0x44, 0x49, 0x7d, 0x11, 0xe6, 0xfb,
-	0xf6, 0xe6, 0x83, 0xb0, 0xb9, 0x10, 0xea, 0x55, 0xd5, 0xf6, 0x5c, 0x9e, 0xc1, 0x5e, 0xd7, 0xa5,
-	0x63, 0xf4, 0x7f, 0x62, 0xec, 0x76, 0x90, 0x96, 0xf6, 0x02, 0xc6, 0xba, 0x5e, 0xa6, 0x99, 0x9b,
-	0xf2, 0x07, 0x86, 0x72, 0x18, 0x6e, 0xbd, 0x06, 0x3a, 0xd2, 0x1b, 0xd1, 0xa2, 0x67, 0xfe, 0x99,
-	0x4f, 0xbf, 0x07, 0x00, 0x00, 0xff, 0xff, 0xe3, 0xad, 0x60, 0xf9, 0x42, 0x05, 0x00, 0x00,
+	// 634 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0x4f, 0x6f, 0xd3, 0x4e,
+	0x10, 0x95, 0x6b, 0x3b, 0x7f, 0xc6, 0x49, 0xd3, 0xee, 0xaf, 0xed, 0xcf, 0xf4, 0x80, 0x8c, 0x55,
+	0xa1, 0x88, 0x3f, 0x46, 0x4a, 0xc5, 0x09, 0x0e, 0x40, 0x51, 0x25, 0x0e, 0x15, 0xb0, 0x2d, 0x67,
+	0xcb, 0x89, 0xb7, 0xed, 0x22, 0x7b, 0xd7, 0xda, 0x5d, 0x37, 0xe9, 0x57, 0xe2, 0xca, 0x97, 0xe2,
+	0xc8, 0x47, 0x40, 0x5e, 0x7b, 0x1d, 0x03, 0x29, 0x70, 0xf3, 0x9b, 0x79, 0x6f, 0x3c, 0x6f, 0x66,
+	0x6c, 0xf0, 0x8a, 0xf9, 0xb3, 0x62, 0x1e, 0x15, 0x82, 0x2b, 0x1e, 0x7e, 0xb3, 0x60, 0x70, 0x46,
+	0x54, 0x92, 0x26, 0x2a, 0x41, 0x3e, 0xf4, 0x6f, 0x88, 0x90, 0x94, 0x33, 0xdf, 0x0a, 0xac, 0xa9,
+	0x8b, 0x0d, 0xac, 0x32, 0x8b, 0x3c, 0xcd, 0x28, 0x23, 0xfe, 0x56, 0x60, 0x4d, 0x87, 0xd8, 0x40,
+	0x74, 0x1f, 0x40, 0x90, 0x82, 0x4b, 0xaa, 0xb8, 0xb8, 0xf5, 0x6d, 0x9d, 0xec, 0x44, 0xd0, 0x43,
+	0x98, 0xcc, 0xc9, 0x15, 0x65, 0x71, 0xc9, 0xe8, 0x2a, 0x56, 0x34, 0x27, 0xbe, 0x13, 0x58, 0x53,
+	0x1b, 0x8f, 0x75, 0xf8, 0x13, 0xa3, 0xab, 0x0b, 0x9a, 0x13, 0x14, 0xc2, 0x98, 0xb0, 0xb4, 0xc3,
+	0x72, 0x35, 0xcb, 0x23, 0x2c, 0x6d, 0x39, 0x01, 0x78, 0x57, 0x22, 0x61, 0x65, 0x96, 0x08, 0xaa,
+	0x6e, 0xfd, 0x9e, 0xee, 0xb1, 0x1b, 0x42, 0x87, 0x30, 0x90, 0x49, 0x5e, 0x64, 0x94, 0x5d, 0xf9,
+	0x7d, 0x9d, 0x6e, 0x71, 0x78, 0x0c, 0xff, 0xbf, 0x29, 0x05, 0x4b, 0xf9, 0x92, 0x9d, 0x17, 0x89,
+	0x90, 0xe4, 0x2c, 0x51, 0x82, 0xae, 0x30, 0x5f, 0x6a, 0x7b, 0x3c, 0x2b, 0x73, 0x26, 0x7d, 0x2b,
+	0xb0, 0xa7, 0x63, 0x6c, 0x60, 0xf8, 0xc5, 0x82, 0xbd, 0x4d, 0x2a, 0x84, 0xc0, 0x61, 0x49, 0x4e,
+	0xf4, 0xa0, 0x86, 0x58, 0x3f, 0xa3, 0x23, 0xd8, 0x66, 0x65, 0x3e, 0x27, 0x22, 0xe6, 0x97, 0xb1,
+	0xe0, 0x4b, 0xa9, 0x87, 0xe5, 0xe2, 0x51, 0x1d, 0x7d, 0x7f, 0x89, 0xf9, 0x52, 0xa2, 0x47, 0xb0,
+	0xbb, 0x66, 0x99, 0xd7, 0xda, 0x9a, 0x38, 0x31, 0xc4, 0x93, 0x3a, 0x8c, 0x9e, 0x80, 0xa3, 0xeb,
+	0x38, 0x81, 0x3d, 0xf5, 0x66, 0x7e, 0x74, 0x87, 0x01, 0xac, 0x59, 0xe1, 0x57, 0x0b, 0xee, 0x9d,
+	0xf0, 0xbc, 0x10, 0x44, 0x4a, 0x92, 0xd6, 0x1c, 0xcc, 0x97, 0x4d, 0xc7, 0xbf, 0x77, 0x67, 0xfd,
+	0x6b, 0x77, 0x5b, 0x9b, 0xbb, 0x43, 0xe0, 0x54, 0x77, 0xe3, 0xdb, 0x81, 0x3d, 0xb5, 0xb1, 0x63,
+	0x6e, 0x88, 0xb2, 0x94, 0x2e, 0x48, 0xdd, 0xb4, 0x8b, 0x0d, 0x44, 0x07, 0xd0, 0xa3, 0x2c, 0x2d,
+	0x94, 0xf0, 0x5d, 0xcd, 0x6f, 0x50, 0x78, 0x0e, 0xfd, 0x13, 0x5e, 0x16, 0x19, 0x91, 0x68, 0x0f,
+	0x5c, 0xca, 0x52, 0xb2, 0xd2, 0x5b, 0x18, 0xe2, 0x1a, 0xa0, 0x19, 0xf4, 0x72, 0x6d, 0x41, 0xf7,
+	0xe1, 0xcd, 0x0e, 0xa3, 0x3b, 0x4d, 0xe2, 0x86, 0x19, 0x1e, 0xc1, 0xe8, 0x82, 0x97, 0x8b, 0x6b,
+	0x92, 0x9e, 0xd2, 0xa6, 0xf2, 0x65, 0xf5, 0xa0, 0x2b, 0xbb, 0xb8, 0x06, 0xe1, 0x29, 0xec, 0xbf,
+	0x25, 0x37, 0x24, 0xe3, 0x05, 0x11, 0x3f, 0xd1, 0x9f, 0x02, 0xa4, 0x26, 0x51, 0x6b, 0xbc, 0xd9,
+	0x38, 0xea, 0x52, 0x70, 0x87, 0x10, 0x7e, 0xb7, 0x61, 0xf2, 0x9a, 0x25, 0xd9, 0xad, 0xa4, 0x12,
+	0x13, 0x59, 0x66, 0x4a, 0xa2, 0x07, 0xd0, 0xbb, 0x26, 0x49, 0x4a, 0x84, 0x1e, 0xb3, 0x37, 0x1b,
+	0x46, 0xe6, 0x3b, 0xc3, 0x4d, 0x02, 0xbd, 0x82, 0x9d, 0x79, 0xb3, 0xd0, 0xb8, 0x10, 0xfc, 0x33,
+	0x59, 0xa8, 0xc6, 0xe2, 0xfe, 0xe6, 0x4d, 0x4f, 0x0c, 0xfd, 0x43, 0xcd, 0x46, 0x2f, 0x61, 0xbb,
+	0xad, 0x50, 0xfb, 0xb3, 0x75, 0xaf, 0x77, 0xe8, 0xc7, 0x86, 0x5c, 0xbb, 0x3c, 0x85, 0xff, 0x5a,
+	0x75, 0xc7, 0xae, 0xf3, 0xa7, 0x12, 0xc8, 0x28, 0xda, 0xc1, 0x49, 0xf4, 0x11, 0x0e, 0xd6, 0xf2,
+	0x98, 0x32, 0x45, 0x44, 0xb2, 0x50, 0xd5, 0x6f, 0xc4, 0xfd, 0xeb, 0xc2, 0xf6, 0xd7, 0xca, 0x77,
+	0x6b, 0x21, 0x7a, 0x0c, 0xa3, 0xca, 0x4f, 0xbc, 0xa8, 0x2f, 0x43, 0x7f, 0xeb, 0xde, 0x6c, 0x10,
+	0x35, 0x97, 0x82, 0xbd, 0x2a, 0x6b, 0xce, 0xe6, 0x39, 0xec, 0xb6, 0x55, 0x5a, 0x45, 0xff, 0x17,
+	0xc5, 0x4e, 0x4b, 0x31, 0xb2, 0x17, 0x30, 0x56, 0xf5, 0x46, 0x9b, 0xd9, 0x0d, 0xb4, 0xe4, 0x20,
+	0xda, 0x78, 0x13, 0x78, 0xa4, 0x3a, 0x68, 0xde, 0xd3, 0xff, 0xcf, 0xe3, 0x1f, 0x01, 0x00, 0x00,
+	0xff, 0xff, 0x0e, 0x2b, 0xec, 0x5d, 0x4e, 0x05, 0x00, 0x00,
 }

pb/pb.proto

@@ -20,7 +20,7 @@ message Metadata {
 message BurndownSparseMatrixRow {
     // the first `len(column)` elements are stored,
     // the rest `number_of_columns - len(column)` values are zeros
-    repeated uint32 column = 1;
+    repeated uint32 columns = 1;
 }
 
 message BurndownSparseMatrix {
@@ -28,7 +28,7 @@ message BurndownSparseMatrix {
     int32 number_of_rows = 2;
     int32 number_of_columns = 3;
     // `len(row)` matches `number_of_rows`
-    repeated BurndownSparseMatrixRow row = 4;
+    repeated BurndownSparseMatrixRow rows = 4;
 }
 
 message CompressedSparseRowMatrix {
@@ -48,12 +48,12 @@ message Couples {
 }
 
 message TouchedFiles {
-    repeated int32 file = 1;  // values correspond to `file_couples::index`
+    repeated int32 files = 1;  // values correspond to `file_couples::index`
 }
 
 message DeveloperTouchedFiles {
     // order corresponds to `developer_couples::index`
-    repeated TouchedFiles developer = 1;
+    repeated TouchedFiles developers = 1;
 }
 
 message AnalysisResults {
@@ -62,10 +62,10 @@ message AnalysisResults {
     BurndownSparseMatrix burndown_project = 2;
 
     // this is included if `-files` was specified
-    repeated BurndownSparseMatrix burndown_file = 3;
+    repeated BurndownSparseMatrix burndown_files = 3;
 
     // these two are included if `-people` was specified
-    repeated BurndownSparseMatrix burndown_developer = 4;
+    repeated BurndownSparseMatrix burndown_developers = 4;
     // rows and cols order correspond to `burndown_developer`
     CompressedSparseRowMatrix developers_interaction = 5;
 

pb/utils.go

@@ -5,7 +5,7 @@ func ToBurndownSparseMatrix(matrix [][]int64, name string) *BurndownSparseMatrix
 	  Name: name,
 	  NumberOfRows: int32(len(matrix)),
 	  NumberOfColumns: int32(len(matrix[len(matrix)-1])),
-	  Row: make([]*BurndownSparseMatrixRow, len(matrix)),
+	  Rows: make([]*BurndownSparseMatrixRow, len(matrix)),
   }
   for i, status := range matrix {
 	  nnz := make([]uint32, 0, len(status))
@@ -22,11 +22,11 @@ func ToBurndownSparseMatrix(matrix [][]int64, name string) *BurndownSparseMatrix
 			  nnz = append(nnz, uint32(v))
 		  }
 	  }
-	  r.Row[i] = &BurndownSparseMatrixRow{
-		  Column: make([]uint32, len(nnz)),
+	  r.Rows[i] = &BurndownSparseMatrixRow{
+		  Columns: make([]uint32, len(nnz)),
 	  }
 	  for j := range nnz {
-		  r.Row[i].Column[j] = nnz[len(nnz) - 1 - j]
+		  r.Rows[i].Columns[j] = nnz[len(nnz) - 1 - j]
 	  }
 	}
 	return &r
@@ -42,15 +42,15 @@ func DenseToCompressedSparseRowMatrix(matrix [][]int64) *CompressedSparseRowMatr
 	}
 	r.Indptr[0] = 0
 	for _, row := range matrix {
+		nnz := 0
 		for x, col := range row {
-			nnz := 0
 			if col != 0 {
 				r.Data = append(r.Data, col)
 				r.Indices = append(r.Indices, int32(x))
 				nnz += 1
 			}
-			r.Indptr = append(r.Indptr, r.Indptr[len(r.Indptr) - 1] + int64(nnz))
 		}
+		r.Indptr = append(r.Indptr, r.Indptr[len(r.Indptr) - 1] + int64(nnz))
 	}
 	return &r
 }
@@ -68,8 +68,8 @@ func MapToCompressedSparseRowMatrix(matrix []map[int]int64) *CompressedSparseRow
 		for x, col := range row {
 			r.Data = append(r.Data, col)
 			r.Indices = append(r.Indices, int32(x))
-			r.Indptr = append(r.Indptr, r.Indptr[len(r.Indptr) - 1] + int64(len(row)))
 		}
+		r.Indptr = append(r.Indptr, r.Indptr[len(r.Indptr) - 1] + int64(len(row)))
 	}
 	return &r
 }