Task 264: .GO File Format

1. Properties of the .GO File Format Intrinsic to Its File System

The .GO file format corresponds to the OBO flat file format utilized for representing the Gene Ontology (GO), a structured vocabulary for biological functions. This format is text-based and consists of a header section followed by stanzas that describe ontology elements. The specifications are detailed in the OBO Flat File Format Guide, version 1.4. The properties (tags) are key-value pairs that define metadata and ontology structures. These are intrinsic to the format's structure, enabling the representation of ontologies in a file system-compatible manner.

The file structure includes:

• A header with tag-value pairs providing ontology metadata.
• Zero or more stanzas, each starting with a type in square brackets (e.g., [Term]), followed by tag-value pairs.
• Supported stanza types: [Term] (for classes), [Typedef] (for relationship types), and [Instance] (for instances).
• Lines are parsed as tag: value, with optional modifiers and comments (ignored after unescaped !).
• Required elements include the format-version header tag and id in each stanza.

Below is a comprehensive enumeration of all properties (tags), categorized by header and stanza type, including descriptions, cardinality, and examples where applicable (derived from the format guide).

Header Tags

These appear at the file's beginning and apply to the entire ontology.

Stanza Tags for [Term]

These describe ontology classes (terms).

Stanza Tags for [Typedef]

These describe relationship types.

Stanza Tags for [Instance]

These describe instances.

2. Two Direct Download Links for Files of Format .GO

Direct download links for example .GO files (in OBO format for Gene Ontology) are as follows:

• http://current.geneontology.org/ontology/go.obo
• http://current.geneontology.org/ontology/go-basic.obo

These files contain the full Gene Ontology in the specified format.

3. Ghost Blog Embedded HTML JavaScript for Drag-and-Drop .GO File Dump

The following is an embeddable HTML snippet with JavaScript suitable for a Ghost blog post. It enables users to drag and drop a .GO (OBO) file, parses it, and dumps all properties (header and stanza tags with values) to the screen in a structured list.

4. Python Class for Handling .GO Files

The following Python class opens a .GO (OBO) file, decodes (parses) its content, reads the properties, allows writing back to a new file, and prints properties to the console.

class GoFile:
    def __init__(self, filename):
        self.filename = filename
        self.header = {}
        self.stanzas = []
        self.parse()

    def parse(self):
        with open(self.filename, 'r') as f:
            content = f.read()
        lines = [line.strip() for line in content.split('\n') if line.strip() and not line.strip().startswith('!')]
        current_stanza = None
        in_header = True
        for line in lines:
            if line.startswith('['):
                in_header = False
                if current_stanza:
                    self.stanzas.append(current_stanza)
                current_stanza = {'type': line, 'tags': {}}
            else:
                parts = line.split(':', 1)
                if len(parts) == 2:
                    tag = parts[0].strip()
                    value = parts[1].split('!')[0].strip()  # Ignore comments
                    if in_header:
                        if tag not in self.header:
                            self.header[tag] = []
                        self.header[tag].append(value)
                    elif current_stanza:
                        if tag not in current_stanza['tags']:
                            current_stanza['tags'][tag] = []
                        current_stanza['tags'][tag].append(value)
        if current_stanza:
            self.stanzas.append(current_stanza)

    def get_properties(self):
        return {'header': self.header, 'stanzas': self.stanzas}

    def print_properties(self):
        print("Header Properties:")
        for tag, values in self.header.items():
            for value in values:
                print(f"{tag}: {value}")
        print("\nStanzas:")
        for i, stanza in enumerate(self.stanzas, 1):
            print(f"Stanza {i}: {stanza['type']}")
            for tag, values in stanza['tags'].items():
                for value in values:
                    print(f"  {tag}: {value}")

    def write(self, output_filename):
        with open(output_filename, 'w') as f:
            # Write header
            for tag, values in self.header.items():
                for value in values:
                    f.write(f"{tag}: {value}\n")
            f.write("\n")
            # Write stanzas
            for stanza in self.stanzas:
                f.write(f"{stanza['type']}\n")
                for tag, values in stanza['tags'].items():
                    for value in values:
                        f.write(f"{tag}: {value}\n")
                f.write("\n")

5. Java Class for Handling .GO Files

The following Java class opens a .GO (OBO) file, decodes its content, reads properties, allows writing to a new file, and prints properties to the console.

import java.io.*;
import java.util.*;

public class GoFile {
    private String filename;
    private Map<String, List<String>> header = new LinkedHashMap<>();
    private List<Map<String, Object>> stanzas = new ArrayList<>();

    public GoFile(String filename) {
        this.filename = filename;
        parse();
    }

    private void parse() {
        try (BufferedReader reader = new BufferedReader(new FileReader(filename))) {
            String line;
            Map<String, List<String>> currentStanzaTags = null;
            String currentStanzaType = null;
            boolean inHeader = true;
            while ((line = reader.readLine()) != null) {
                line = line.trim();
                if (line.isEmpty() || line.startsWith("!")) continue;
                if (line.startsWith("[")) {
                    inHeader = false;
                    if (currentStanzaType != null) {
                        Map<String, Object> stanza = new HashMap<>();
                        stanza.put("type", currentStanzaType);
                        stanza.put("tags", currentStanzaTags);
                        stanzas.add(stanza);
                    }
                    currentStanzaType = line;
                    currentStanzaTags = new LinkedHashMap<>();
                } else {
                    String[] parts = line.split(":", 2);
                    if (parts.length == 2) {
                        String tag = parts[0].trim();
                        String value = parts[1].split("!")[0].trim();
                        if (inHeader) {
                            header.computeIfAbsent(tag, k -> new ArrayList<>()).add(value);
                        } else if (currentStanzaTags != null) {
                            currentStanzaTags.computeIfAbsent(tag, k -> new ArrayList<>()).add(value);
                        }
                    }
                }
            }
            if (currentStanzaType != null) {
                Map<String, Object> stanza = new HashMap<>();
                stanza.put("type", currentStanzaType);
                stanza.put("tags", currentStanzaTags);
                stanzas.add(stanza);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public Map<String, Object> getProperties() {
        Map<String, Object> properties = new HashMap<>();
        properties.put("header", header);
        properties.put("stanzas", stanzas);
        return properties;
    }

    public void printProperties() {
        System.out.println("Header Properties:");
        for (Map.Entry<String, List<String>> entry : header.entrySet()) {
            for (String value : entry.getValue()) {
                System.out.println(entry.getKey() + ": " + value);
            }
        }
        System.out.println("\nStanzas:");
        for (int i = 0; i < stanzas.size(); i++) {
            Map<String, Object> stanza = stanzas.get(i);
            System.out.println("Stanza " + (i + 1) + ": " + stanza.get("type"));
            @SuppressWarnings("unchecked")
            Map<String, List<String>> tags = (Map<String, List<String>>) stanza.get("tags");
            for (Map.Entry<String, List<String>> entry : tags.entrySet()) {
                for (String value : entry.getValue()) {
                    System.out.println("  " + entry.getKey() + ": " + value);
                }
            }
        }
    }

    public void write(String outputFilename) {
        try (PrintWriter writer = new PrintWriter(new File(outputFilename))) {
            // Write header
            for (Map.Entry<String, List<String>> entry : header.entrySet()) {
                for (String value : entry.getValue()) {
                    writer.println(entry.getKey() + ": " + value);
                }
            }
            writer.println();
            // Write stanzas
            for (Map<String, Object> stanza : stanzas) {
                writer.println(stanza.get("type"));
                @SuppressWarnings("unchecked")
                Map<String, List<String>> tags = (Map<String, List<String>>) stanza.get("tags");
                for (Map.Entry<String, List<String>> entry : tags.entrySet()) {
                    for (String value : entry.getValue()) {
                        writer.println(entry.getKey() + ": " + value);
                    }
                }
                writer.println();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

6. JavaScript Class for Handling .GO Files

The following JavaScript class opens a .GO (OBO) file (using Node.js fs module), decodes its content, reads properties, allows writing to a new file, and prints properties to the console.

const fs = require('fs');

class GoFile {
  constructor(filename) {
    this.filename = filename;
    this.header = {};
    this.stanzas = [];
    this.parse();
  }

  parse() {
    const content = fs.readFileSync(this.filename, 'utf8');
    const lines = content.split('\n').filter(line => line.trim() && !line.trim().startsWith('!'));
    let currentStanza = null;
    let inHeader = true;
    lines.forEach(line => {
      if (line.startsWith('[')) {
        inHeader = false;
        if (currentStanza) this.stanzas.push(currentStanza);
        currentStanza = { type: line, tags: {} };
      } else {
        const match = line.match(/^([^:]+):\s*(.*)/);
        if (match) {
          const tag = match[1].trim();
          const value = match[2].split('!')[0].trim();
          if (inHeader) {
            if (!this.header[tag]) this.header[tag] = [];
            this.header[tag].push(value);
          } else if (currentStanza) {
            if (!currentStanza.tags[tag]) currentStanza.tags[tag] = [];
            currentStanza.tags[tag].push(value);
          }
        }
      }
    });
    if (currentStanza) this.stanzas.push(currentStanza);
  }

  getProperties() {
    return { header: this.header, stanzas: this.stanzas };
  }

  printProperties() {
    console.log('Header Properties:');
    for (const [tag, values] of Object.entries(this.header)) {
      values.forEach(value => console.log(`${tag}: ${value}`));
    }
    console.log('\nStanzas:');
    this.stanzas.forEach((stanza, index) => {
      console.log(`Stanza ${index + 1}: ${stanza.type}`);
      for (const [tag, values] of Object.entries(stanza.tags)) {
        values.forEach(value => console.log(`  ${tag}: ${value}`));
      }
    });
  }

  write(outputFilename) {
    let output = '';
    // Write header
    for (const [tag, values] of Object.entries(this.header)) {
      values.forEach(value => output += `${tag}: ${value}\n`);
    }
    output += '\n';
    // Write stanzas
    this.stanzas.forEach(stanza => {
      output += `${stanza.type}\n`;
      for (const [tag, values] of Object.entries(stanza.tags)) {
        values.forEach(value => output += `${tag}: ${value}\n`);
      }
      output += '\n';
    });
    fs.writeFileSync(outputFilename, output);
  }
}

7. C++ Class for Handling .GO Files

The following C++ class opens a .GO (OBO) file, decodes its content, reads properties, allows writing to a new file, and prints properties to the console.

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <map>
#include <string>

class GoFile {
private:
    std::string filename;
    std::map<std::string, std::vector<std::string>> header;
    std::vector<std::map<std::string, std::string>> stanzas;  // type + tags (tags as map<string, vector<string>>)

public:
    GoFile(const std::string& fn) : filename(fn) {
        parse();
    }

    void parse() {
        std::ifstream file(filename);
        if (!file.is_open()) {
            std::cerr << "Error opening file: " << filename << std::endl;
            return;
        }
        std::string line;
        std::map<std::string, std::vector<std::string>> currentStanzaTags;
        std::string currentStanzaType;
        bool inHeader = true;
        while (std::getline(file, line)) {
            line.erase(0, line.find_first_not_of(" \t"));  // Trim left
            line.erase(line.find_last_not_of(" \t") + 1);  // Trim right
            if (line.empty() || line[0] == '!') continue;
            if (line[0] == '[') {
                inHeader = false;
                if (!currentStanzaType.empty()) {
                    std::map<std::string, std::string> stanza;
                    stanza["type"] = currentStanzaType;
                    for (const auto& pair : currentStanzaTags) {
                        std::stringstream ss;
                        for (const auto& val : pair.second) {
                            ss << val << "; ";
                        }
                        stanza[pair.first] = ss.str();
                    }
                    stanzas.push_back(stanza);
                }
                currentStanzaType = line;
                currentStanzaTags.clear();
            } else {
                size_t colonPos = line.find(':');
                if (colonPos != std::string::npos) {
                    std::string tag = line.substr(0, colonPos);
                    tag.erase(tag.find_last_not_of(" \t") + 1);  // Trim
                    std::string value = line.substr(colonPos + 1);
                    value.erase(0, value.find_first_not_of(" \t"));
                    size_t commentPos = value.find('!');
                    if (commentPos != std::string::npos) value = value.substr(0, commentPos);
                    value.erase(value.find_last_not_of(" \t") + 1);
                    if (inHeader) {
                        header[tag].push_back(value);
                    } else {
                        currentStanzaTags[tag].push_back(value);
                    }
                }
            }
        }
        if (!currentStanzaType.empty()) {
            std::map<std::string, std::string> stanza;
            stanza["type"] = currentStanzaType;
            for (const auto& pair : currentStanzaTags) {
                std::stringstream ss;
                for (const auto& val : pair.second) {
                    ss << val << "; ";
                }
                stanza[pair.first] = ss.str();
            }
            stanzas.push_back(stanza);
        }
        file.close();
    }

    std::map<std::string, std::vector<std::string>> getHeader() const {
        return header;
    }

    std::vector<std::map<std::string, std::string>> getStanzas() const {
        return stanzas;
    }

    void printProperties() const {
        std::cout << "Header Properties:" << std::endl;
        for (const auto& pair : header) {
            for (const auto& value : pair.second) {
                std::cout << pair.first << ": " << value << std::endl;
            }
        }
        std::cout << "\nStanzas:" << std::endl;
        for (size_t i = 0; i < stanzas.size(); ++i) {
            const auto& stanza = stanzas[i];
            std::cout << "Stanza " << (i + 1) << ": " << stanza.at("type") << std::endl;
            for (const auto& pair : stanza) {
                if (pair.first != "type") {
                    std::cout << "  " << pair.first << ": " << pair.second << std::endl;
                }
            }
        }
    }

    void write(const std::string& outputFilename) const {
        std::ofstream outFile(outputFilename);
        if (!outFile.is_open()) {
            std::cerr << "Error opening output file: " << outputFilename << std::endl;
            return;
        }
        // Write header
        for (const auto& pair : header) {
            for (const auto& value : pair.second) {
                outFile << pair.first << ": " << value << "\n";
            }
        }
        outFile << "\n";
        // Write stanzas
        for (const auto& stanza : stanzas) {
            outFile << stanza.at("type") << "\n";
            for (const auto& pair : stanza) {
                if (pair.first != "type") {
                    // Split semi-colon for multi-values
                    std::string values = pair.second;
                    size_t pos = 0;
                    while ((pos = values.find("; ")) != std::string::npos) {
                        outFile << pair.first << ": " << values.substr(0, pos) << "\n";
                        values.erase(0, pos + 2);
                    }
                    if (!values.empty()) outFile << pair.first << ": " << values << "\n";
                }
            }
            outFile << "\n";
        }
        outFile.close();
    }
};