diff --git a/aprslib/packets/base.py b/aprslib/packets/base.py
index 8058f27..aa9318c 100644
--- a/aprslib/packets/base.py
+++ b/aprslib/packets/base.py
@@ -1,5 +1,5 @@
 from aprslib import parse
-from aprslib.parsing.common import _parse_header
+from aprslib.parsing.common import parse_header
 
 class APRSPacket(object):
     format = 'raw'
@@ -42,7 +42,7 @@ class APRSPacket(object):
         if not isinstance(obj, dict):
             if self.format == 'raw':
                 header, self.body = obj.split(":", 1)
-                obj = _parse_header(header)
+                obj = parse_header(header)
             else:
                 obj = parse(obj)
 
diff --git a/aprslib/parsing/__init__.py b/aprslib/parsing/__init__.py
index 092bef4..43e9766 100644
--- a/aprslib/parsing/__init__.py
+++ b/aprslib/parsing/__init__.py
@@ -98,7 +98,7 @@ def parse(packet):
 
     # parse head
     try:
-        parsed.update(_parse_header(head))
+        parsed.update(parse_header(head))
     except ParseError as msg:
         raise ParseError(str(msg), packet)
 
@@ -111,7 +111,7 @@ def parse(packet):
 
     # attempt to parse the body
     try:
-        _try_to_parse_body(packet_type, body, parsed)
+        _try_toparse_body(packet_type, body, parsed)
 
     # capture ParseErrors and attach the packet
     except (UnknownFormat, ParseError) as exp:
@@ -135,7 +135,7 @@ def parse(packet):
     return parsed
 
 
-def _try_to_parse_body(packet_type, body, parsed):
+def _try_toparse_body(packet_type, body, parsed):
     result = {}
 
     # NOT SUPPORTED FORMATS
@@ -165,43 +165,43 @@ def _try_to_parse_body(packet_type, body, parsed):
     elif packet_type == ',':
         logger.debug("Packet is invalid format")
 
-        body, result = _parse_invalid(body)
+        body, result = parse_invalid(body)
 
     # user defined
     elif packet_type == '{':
         logger.debug("Packet is user-defined")
 
-        body, result = _parse_user_defined(body)
+        body, result = parse_user_defined(body)
 
     # Status report
     elif packet_type == '>':
         logger.debug("Packet is just a status message")
 
-        body, result = _parse_status(packet_type, body)
+        body, result = parse_status(packet_type, body)
 
     # Mic-encoded packet
     elif packet_type in "`'":
         logger.debug("Attempting to parse as mic-e packet")
 
-        body, result = _parse_mice(parsed['to'], body)
+        body, result = parse_mice(parsed['to'], body)
 
     # Message packet
     elif packet_type == ':':
         logger.debug("Attempting to parse as message packet")
 
-        body, result = _parse_message(body)
+        body, result = parse_message(body)
 
     # Positionless weather report
     elif packet_type == '_':
         logger.debug("Attempting to parse as positionless weather report")
 
-        body, result = _parse_weather(body)
+        body, result = parse_weather(body)
 
     # postion report (regular or compressed)
     elif (packet_type in '!=/@;' or
           0 <= body.find('!') < 40):  # page 28 of spec (PDF)
 
-        body, result = _parse_position(packet_type, body)
+        body, result = parse_position(packet_type, body)
 
     # we are done
     parsed.update(result)
diff --git a/aprslib/parsing/common.py b/aprslib/parsing/common.py
index b4f85ef..a4b2293 100644
--- a/aprslib/parsing/common.py
+++ b/aprslib/parsing/common.py
@@ -4,16 +4,16 @@ from datetime import datetime
 from aprslib import base91
 from aprslib.exceptions import ParseError
 from aprslib.parsing import logger
-from aprslib.parsing.telemetry import _parse_comment_telemetry
+from aprslib.parsing.telemetry import parse_comment_telemetry
 
 __all__ = [
-    '_validate_callsign',
-    '_parse_header',
-    '_parse_timestamp',
-    '_parse_comment',
+    'validate_callsign',
+    'parse_header',
+    'parse_timestamp',
+    'parse_comment',
     ]
 
-def _validate_callsign(callsign, prefix=""):
+def validate_callsign(callsign, prefix=""):
     prefix = '%s: ' % prefix if bool(prefix) else ''
 
     match = re.findall(r"^([A-Z0-9]{1,6})(-(\d{1,2}))?$", callsign)
@@ -27,27 +27,16 @@ def _validate_callsign(callsign, prefix=""):
         raise ParseError("%sssid not in 0-15 range" % prefix)
 
 
-def _parse_header(head):
+def parse_header(head):
     """
     Parses the header part of packet
     Returns a dict
     """
-    #  CALL1>CALL2,CALL3,CALL4,CALL5:
-    # |from-|--to-|------path-------|
-    #
     try:
         (fromcall, path) = head.split('>', 1)
     except:
         raise ParseError("invalid packet header")
 
-    # looking at aprs.fi, the rules for from/src callsign
-    # are a lot looser, causing a lot of packets to fail
-    # this check.
-    #
-    # if len(fromcall) == 0:
-    #    raise ParseError("no fromcallsign in header")
-    # _validate_callsign(fromcall, "fromcallsign")
-
     if (not 1 <= len(fromcall) <= 9 or
        not re.findall(r"^[a-z0-9]{0,9}(\-[a-z0-9]{1,8})?$", fromcall, re.I)):
 
@@ -61,7 +50,7 @@ def _parse_header(head):
     tocall = path[0]
     path = path[1:]
 
-    _validate_callsign(tocall, "tocallsign")
+    validate_callsign(tocall, "tocallsign")
 
     for digi in path:
         if not re.findall(r"^[A-Z0-9\-]{1,9}\*?$", digi, re.I):
@@ -73,12 +62,6 @@ def _parse_header(head):
         'path': path,
         }
 
-    # viacall is the callsign that gated the packet to the net
-    # it's located behind the q-contructed
-    #
-    #  CALL1>CALL2,CALL3,qAR,CALL5:
-    #  .....................|-via-|
-    #
     viacall = ""
     if len(path) >= 2 and re.match(r"^q..$", path[-2]):
         viacall = path[-1]
@@ -88,7 +71,7 @@ def _parse_header(head):
     return parsed
 
 
-def _parse_timestamp(body, packet_type=''):
+def parse_timestamp(body, packet_type=''):
     parsed = {}
 
     match = re.findall(r"^((\d{6})(.))$", body[0:7])
@@ -127,9 +110,7 @@ def _parse_timestamp(body, packet_type=''):
     return (body, parsed)
 
 
-def _parse_comment(body, parsed):
-    # attempt to parse remaining part of the packet (comment field)
-    # try CRS/SPD
+def parse_comment(body, parsed):
     match = re.findall(r"^([0-9]{3})/([0-9]{3})", body)
     if match:
         cse, spd = match[0]
@@ -167,11 +148,11 @@ def _parse_comment(body, parsed):
 
         parsed.update({'altitude': int(altitude)*0.3048})
 
-    body, telemetry = _parse_comment_telemetry(body)
+    body, telemetry = parse_comment_telemetry(body)
     parsed.update(telemetry)
 
     # parse DAO extention
-    body = _parse_dao(body, parsed)
+    body = parse_dao(body, parsed)
 
     if len(body) > 0 and body[0] == "/":
         body = body[1:]
@@ -179,7 +160,7 @@ def _parse_comment(body, parsed):
     parsed.update({'comment': body.strip(' ')})
 
 
-def _parse_dao(body, parsed):
+def parse_dao(body, parsed):
     match = re.findall("^(.*)\!([\x21-\x7b][\x20-\x7b]{2})\!(.*?)$", body)
     if match:
         body, dao, rest = match[0]
diff --git a/aprslib/parsing/message.py b/aprslib/parsing/message.py
index 2edf744..659dade 100644
--- a/aprslib/parsing/message.py
+++ b/aprslib/parsing/message.py
@@ -1,9 +1,9 @@
 import re
 from aprslib.parsing import logger
-from aprslib.parsing.telemetry import _parse_telemetry_config
+from aprslib.parsing.telemetry import parse_telemetry_config
 
 __all__ = [
-        '_parse_message',
+        'parse_message',
         ]
 
 # MESSAGE PACKET
@@ -18,7 +18,7 @@ __all__ = [
 # :N3MIM:UNIT.Volts,deg.F,deg.F,Mbar,Kfeet,Clik,OPEN!,on,on,high
 # :N3MIM:EQNS.0,2.6,0,0,.53,-32,3,4.39,49,-32,3,18,1,2,3
 # :N3MIM:BITS.10110101,PROJECT TITLE...
-def _parse_message(body):
+def parse_message(body):
     parsed = {}
 
     # the while loop is used to easily break out once a match is found
@@ -63,7 +63,7 @@ def _parse_message(body):
         parsed.update({'addresse': addresse.rstrip(' ')})
 
         # check if it's a telemetry configuration message
-        body, result = _parse_telemetry_config(body)
+        body, result = parse_telemetry_config(body)
         if result:
             parsed.update(result)
             break
diff --git a/aprslib/parsing/mice.py b/aprslib/parsing/mice.py
index 5b7236c..b79231c 100644
--- a/aprslib/parsing/mice.py
+++ b/aprslib/parsing/mice.py
@@ -2,11 +2,11 @@ import re
 import math
 from aprslib import base91
 from aprslib.exceptions import ParseError
-from aprslib.parsing.common import _parse_dao
-from aprslib.parsing.telemetry import _parse_comment_telemetry
+from aprslib.parsing.common import parse_dao
+from aprslib.parsing.telemetry import parse_comment_telemetry
 
 __all__ = [
-        '_parse_mice',
+        'parse_mice',
         ]
 
 # Mic-e message type table
@@ -37,7 +37,7 @@ MTYPE_TABLE_CUSTOM = {
 # 'lllc/s$/.........         Mic-E no message capability
 # 'lllc/s$/>........         Mic-E message capability
 # `lllc/s$/>........         Mic-E old posit
-def _parse_mice(dstcall, body):
+def parse_mice(dstcall, body):
     parsed = {'format': 'mic-e'}
 
     dstcall = dstcall.split('-')[0]
@@ -208,11 +208,11 @@ def _parse_mice(dstcall, body):
             body = body + extra
 
         # attempt to parse comment telemetry
-        body, telemetry = _parse_comment_telemetry(body)
+        body, telemetry = parse_comment_telemetry(body)
         parsed.update(telemetry)
 
         # parse DAO extention
-        body = _parse_dao(body, parsed)
+        body = parse_dao(body, parsed)
 
         # rest is a comment
         parsed.update({'comment': body.strip(' ')})
diff --git a/aprslib/parsing/misc.py b/aprslib/parsing/misc.py
index 5c5524b..44bd3c8 100644
--- a/aprslib/parsing/misc.py
+++ b/aprslib/parsing/misc.py
@@ -1,11 +1,11 @@
 import re
 from aprslib.exceptions import ParseError
-from aprslib.parsing.common import _parse_timestamp
+from aprslib.parsing.common import parse_timestamp
 
 __all__ = [
-        '_parse_status',
-        '_parse_invalid',
-        '_parse_user_defined',
+        'parse_status',
+        'parse_invalid',
+        'parse_user_defined',
         ]
 
 
@@ -13,8 +13,8 @@ __all__ = [
 #
 # >DDHHMMzComments
 # >Comments
-def _parse_status(packet_type, body):
-    body, result = _parse_timestamp(body, packet_type)
+def parse_status(packet_type, body):
+    body, result = parse_timestamp(body, packet_type)
 
     result.update({
         'format': 'status',
@@ -27,7 +27,7 @@ def _parse_status(packet_type, body):
 # INVALID
 #
 # ,.........................
-def _parse_invalid(body):
+def parse_invalid(body):
     return ('', {
         'format': 'invalid',
         'body': body
@@ -38,7 +38,7 @@ def _parse_invalid(body):
 #
 # {A1................
 # {{.................
-def _parse_user_defined(body):
+def parse_user_defined(body):
     return ('', {
         'format': 'user-defined',
         'id': body[0],
diff --git a/aprslib/parsing/position.py b/aprslib/parsing/position.py
index bb08f32..f68b1aa 100644
--- a/aprslib/parsing/position.py
+++ b/aprslib/parsing/position.py
@@ -3,16 +3,16 @@ import re
 from aprslib import base91
 from aprslib.exceptions import ParseError
 from aprslib.parsing import logger
-from aprslib.parsing.common import _parse_timestamp, _parse_comment
-from aprslib.parsing.weather import _parse_weather_data
+from aprslib.parsing.common import parse_timestamp, parse_comment
+from aprslib.parsing.weather import parse_weather_data
 
 __all__ = [
-        '_parse_position',
-        '_parse_compressed',
-        '_parse_normal',
+        'parse_position',
+        'parse_compressed',
+        'parse_normal',
         ]
 
-def _parse_position(packet_type, body):
+def parse_position(packet_type, body):
     parsed = {}
 
     if packet_type not in '!=/@;':
@@ -37,20 +37,20 @@ def _parse_position(packet_type, body):
 
     # decode timestamp
     if packet_type in "/@;":
-        body, result = _parse_timestamp(body, packet_type)
+        body, result = parse_timestamp(body, packet_type)
         parsed.update(result)
 
     if len(body) == 0 and 'timestamp' in parsed:
         raise ParseError("invalid position report format", packet)
 
     # decode body
-    body, result = _parse_compressed(body)
+    body, result = parse_compressed(body)
     parsed.update(result)
 
     if len(result) > 0:
         logger.debug("Parsed as compressed position report")
     else:
-        body, result = _parse_normal(body)
+        body, result = parse_normal(body)
         parsed.update(result)
 
         if len(result) > 0:
@@ -61,14 +61,14 @@ def _parse_position(packet_type, body):
     # Page 62 of the spec
     if parsed['symbol'] == '_':
         logger.debug("Attempting to parse weather report from comment")
-        body, result = _parse_weather_data(body)
+        body, result = parse_weather_data(body)
         parsed.update({
             'comment': body.strip(' '),
             'weather': result,
             })
     else:
         # decode comment
-        _parse_comment(body, parsed)
+        parse_comment(body, parsed)
 
     if packet_type == ';':
         parsed.update({
@@ -78,7 +78,7 @@ def _parse_position(packet_type, body):
 
     return ('', parsed)
 
-def _parse_compressed(body):
+def parse_compressed(body):
     parsed = {}
 
     if re.match(r"^[\/\\A-Za-j][!-|]{8}[!-{}][ -|]{3}", body):
@@ -129,7 +129,7 @@ def _parse_compressed(body):
     return (body, parsed)
 
 
-def _parse_normal(body):
+def parse_normal(body):
     parsed = {}
 
     match = re.findall(r"^(\d{2})([0-9 ]{2}\.[0-9 ]{2})([NnSs])([\/\\0-9A-Z])"
diff --git a/aprslib/parsing/telemetry.py b/aprslib/parsing/telemetry.py
index 89feb1f..a6308af 100644
--- a/aprslib/parsing/telemetry.py
+++ b/aprslib/parsing/telemetry.py
@@ -4,12 +4,12 @@ from aprslib.exceptions import ParseError
 from aprslib.parsing import logger
 
 __all__ = [
-        '_parse_comment_telemetry',
-        '_parse_telemetry_config',
+        'parse_comment_telemetry',
+        'parse_telemetry_config',
         ]
 
 
-def _parse_comment_telemetry(text):
+def parse_comment_telemetry(text):
     """
     Looks for base91 telemetry found in comment field
     Returns [remaining_text, telemetry]
@@ -40,7 +40,7 @@ def _parse_comment_telemetry(text):
     return (text, parsed)
 
 
-def _parse_telemetry_config(body):
+def parse_telemetry_config(body):
     parsed = {}
 
     match = re.findall(r"^(PARM|UNIT|EQNS|BITS)\.(.*)$", body)
diff --git a/aprslib/parsing/weather.py b/aprslib/parsing/weather.py
index 32d6b64..6754f1d 100644
--- a/aprslib/parsing/weather.py
+++ b/aprslib/parsing/weather.py
@@ -2,8 +2,8 @@ import re
 from aprslib.exceptions import ParseError
 
 __all__ = [
-    '_parse_weather',
-    '_parse_weather_data',
+    'parse_weather',
+    'parse_weather_data',
     ]
 
 # constants
@@ -41,7 +41,7 @@ val_map = {
     '#': lambda x: int(x),
 }
 
-def _parse_weather_data(body):
+def parse_weather_data(body):
     parsed = {}
 
     # parse weather data
@@ -58,12 +58,12 @@ def _parse_weather_data(body):
 
     return (body, parsed)
 
-def _parse_weather(body):
+def parse_weather(body):
     match = re.match("^(\d{8})c[\. \d]{3}s[\. \d]{3}g[\. \d]{3}t[\. \d]{3}", body)
     if not match:
         raise ParseError("invalid positionless weather report format")
 
-    comment, weather = _parse_weather_data(body[8:])
+    comment, weather = parse_weather_data(body[8:])
 
     parsed = {
         'format': 'wx',
diff --git a/tests/test_parse.py b/tests/test_parse.py
index c8eee30..0a08938 100644
--- a/tests/test_parse.py
+++ b/tests/test_parse.py
@@ -53,7 +53,7 @@ class ParseTestCase(unittest.TestCase):
     def test_empty_body(self):
         self.assertRaises(ParseError, parse, "A>B:")
 
-    def test_parse_header_exception(self):
+    def testparse_header_exception(self):
         self.assertRaises(ParseError, parse, "A:asd")
 
     def test_empty_body_of_format_that_is_not_status(self):
@@ -104,9 +104,9 @@ class ParseBranchesTestCase(unittest.TestCase):
         self.assertEqual(result, expected)
 
     def test_mice_format_branch(self):
-        self.m.StubOutWithMock(parsing, "_parse_mice")
-        parsing._parse_mice("B", "test").AndReturn(('', {'format': ''}))
-        parsing._parse_mice("D", "test").AndReturn(('', {'format': ''}))
+        self.m.StubOutWithMock(parsing, "parse_mice")
+        parsing.parse_mice("B", "test").AndReturn(('', {'format': ''}))
+        parsing.parse_mice("D", "test").AndReturn(('', {'format': ''}))
         self.m.ReplayAll()
 
         parse("A>B:`test")
@@ -115,8 +115,8 @@ class ParseBranchesTestCase(unittest.TestCase):
         self.m.VerifyAll()
 
     def test_message_format_branch(self):
-        self.m.StubOutWithMock(parsing, "_parse_message")
-        parsing._parse_message("test").AndReturn(('', {'format': ''}))
+        self.m.StubOutWithMock(parsing, "parse_message")
+        parsing.parse_message("test").AndReturn(('', {'format': ''}))
         self.m.ReplayAll()
 
         parse("A>B::test")
diff --git a/tests/test_parse_comment_telemetry.py b/tests/test_parse_comment_telemetry.py
index 5c9058d..91b7ab8 100644
--- a/tests/test_parse_comment_telemetry.py
+++ b/tests/test_parse_comment_telemetry.py
@@ -1,6 +1,6 @@
 import unittest2 as unittest
 
-from aprslib.parsing import _parse_comment_telemetry
+from aprslib.parsing import parse_comment_telemetry
 from aprslib import base91
 from random import randint
 
@@ -52,7 +52,7 @@ class ParseCommentTelemetry(unittest.TestCase):
 
             testData = self.genTelem(i, vals, bits)
 
-            extra, resData = _parse_comment_telemetry(self.telemString(testData))
+            extra, resData = parse_comment_telemetry(self.telemString(testData))
             resData = resData['telemetry']
 
             # clean up extra data, so we can compare
@@ -79,7 +79,7 @@ class ParseCommentTelemetry(unittest.TestCase):
             ]
 
         for datum in testData:
-            extra, telem = _parse_comment_telemetry("".join(datum))
+            extra, telem = parse_comment_telemetry("".join(datum))
 
             self.assertEqual(datum[0]+datum[2], extra)
 
@@ -107,12 +107,12 @@ class ParseCommentTelemetry(unittest.TestCase):
             ]
 
         for datum in testData:
-            extra, telem = _parse_comment_telemetry(datum)
+            extra, telem = parse_comment_telemetry(datum)
 
             self.assertEqual(datum, extra)
 
     def test_output_format(self):
-        parsedOutput = _parse_comment_telemetry("|aabb|")
+        parsedOutput = parse_comment_telemetry("|aabb|")
 
         self.assertTrue(isinstance(parsedOutput, tuple))
         self.assertTrue(len(parsedOutput) == 2)
diff --git a/tests/test_parse_header.py b/tests/test_parse_header.py
index 15f991f..5ab8481 100644
--- a/tests/test_parse_header.py
+++ b/tests/test_parse_header.py
@@ -2,17 +2,17 @@ import unittest2 as unittest
 import string
 from random import randint, randrange, sample
 
-from aprslib.parsing import _parse_header
-from aprslib.parsing import _validate_callsign
+from aprslib.parsing import parse_header
+from aprslib.parsing import validate_callsign
 from aprslib.exceptions import ParseError
 
 
 class ValidateCallsign(unittest.TestCase):
 
-    def test_valid_input(self):
+    def testvalid_input(self):
         chars = string.ascii_letters.upper() + string.digits
 
-        def random_valid_callsigns():
+        def randomvalid_callsigns():
             for x in range(0, 500):
                 call = "".join(sample(chars, randrange(1, 6)))
 
@@ -21,13 +21,13 @@ class ValidateCallsign(unittest.TestCase):
 
                 yield call
 
-        for call in random_valid_callsigns():
+        for call in randomvalid_callsigns():
             try:
-                _validate_callsign(call)
+                validate_callsign(call)
             except ParseError:
                 self.fail(
                     "%s('%s') raised ParseError" %
-                    (_validate_callsign.__name__, call)
+                    (validate_callsign.__name__, call)
                     )
 
     def test_invalid_input(self):
@@ -43,12 +43,12 @@ class ValidateCallsign(unittest.TestCase):
             ]
 
         for call in testData:
-            self.assertRaises(ParseError, _validate_callsign, call)
+            self.assertRaises(ParseError, validate_callsign, call)
 
 
 class ParseHeader(unittest.TestCase):
 
-    def test_valid_input_and_format(self):
+    def testvalid_input_and_format(self):
         # empty path header
         expected = {
             "from": "A",
@@ -56,7 +56,7 @@ class ParseHeader(unittest.TestCase):
             "via": "",
             "path": []
             }
-        result = _parse_header("A>B")
+        result = parse_header("A>B")
 
         self.assertEqual(expected, result)
 
@@ -67,7 +67,7 @@ class ParseHeader(unittest.TestCase):
             "via": "",
             "path": list('CDE')
             }
-        result2 = _parse_header("A>B,C,D,E")
+        result2 = parse_header("A>B,C,D,E")
 
         self.assertEqual(expected2, result2)
 
@@ -78,7 +78,7 @@ class ParseHeader(unittest.TestCase):
             "via": "E",
             "path": ['C', 'D', 'qAR', 'E']
             }
-        result3 = _parse_header("A>B,C,D,qAR,E")
+        result3 = parse_header("A>B,C,D,qAR,E")
 
         self.assertEqual(expected3, result3)
 
@@ -89,11 +89,11 @@ class ParseHeader(unittest.TestCase):
                 "via": "C",
                 "path": [qCon, 'C']
                 }
-            result4 = _parse_header("A>B,%s,C" % qCon)
+            result4 = parse_header("A>B,%s,C" % qCon)
 
             self.assertEqual(expected4, result4)
 
-    def test_valid_fromcallsigns(self):
+    def testvalid_fromcallsigns(self):
         testData = [
             "A>CALL",
             "4>CALL",
@@ -117,10 +117,10 @@ class ParseHeader(unittest.TestCase):
 
         for head in testData:
             try:
-                _parse_header(head)
+                parse_header(head)
             except ParseError as msg:
                 self.fail("{0}('{1}') PraseError, {2}"
-                          .format(_parse_header.__name__, head, msg))
+                          .format(parse_header.__name__, head, msg))
 
     def test_invalid_format(self):
         testData = [
@@ -144,9 +144,9 @@ class ParseHeader(unittest.TestCase):
 
         for head in testData:
             try:
-                _parse_header(head)
+                parse_header(head)
                 self.fail("{0} didn't raise exception for: {1}"
-                          .format(_parse_header.__name__, head))
+                          .format(parse_header.__name__, head))
             except ParseError:
                 continue
 
diff --git a/tests/test_parse_weather_data.py b/tests/test_parse_weather_data.py
index cbc74b7..5312c34 100644
--- a/tests/test_parse_weather_data.py
+++ b/tests/test_parse_weather_data.py
@@ -1,6 +1,6 @@
 import unittest2 as unittest
 
-from aprslib.parsing import _parse_weather_data
+from aprslib.parsing import parse_weather_data
 from aprslib.parsing import parse
 
 wind_multiplier = 0.44704
@@ -16,7 +16,7 @@ class ParseCommentWeather(unittest.TestCase):
             "wind_speed": (9 * wind_multiplier),
             "wind_direction": 9
         }
-        result = _parse_weather_data("009/009")
+        result = parse_weather_data("009/009")
         self.assertEqual(expected, result)
 
         # Daft result but possible
@@ -24,7 +24,7 @@ class ParseCommentWeather(unittest.TestCase):
             "wind_speed": (999 * wind_multiplier),
             "wind_direction": 999
         }
-        result = _parse_weather_data("999/999")
+        result = parse_weather_data("999/999")
         self.assertEqual(expected, result)
 
         #Positionless packet
@@ -32,7 +32,7 @@ class ParseCommentWeather(unittest.TestCase):
             "wind_speed": float(9 * wind_multiplier),
             "wind_direction": 9
         }
-        result = _parse_weather_data("c009s009")
+        result = parse_weather_data("c009s009")
         self.assertEqual(expected, result)
 
         # Daft result but possible
@@ -40,7 +40,7 @@ class ParseCommentWeather(unittest.TestCase):
             "wind_speed": (999 * wind_multiplier),
             "wind_direction": 999
         }
-        result = _parse_weather_data("c999s999")
+        result = parse_weather_data("c999s999")
         self.assertEqual(expected, result)
 
     def test_temp(self):
@@ -48,150 +48,150 @@ class ParseCommentWeather(unittest.TestCase):
         expected = "", {
             "temperature": float((-99.0 - 32) / 1.8)
         }
-        result = _parse_weather_data("t-99")
+        result = parse_weather_data("t-99")
         self.assertEqual(expected, result)
 
         # Misc
         expected = "", {
             "temperature": -40.0
         }
-        result = _parse_weather_data("t-40")
+        result = parse_weather_data("t-40")
         self.assertEqual(expected, result)
 
         # Zero F
         expected = "", {
             "temperature": -17.77777777777778
         }
-        result = _parse_weather_data("t000")
+        result = parse_weather_data("t000")
         self.assertEqual(expected, result)
 
         # Daft, but possible
         expected = "", {
             "temperature": 537.2222222222222
         }
-        result = _parse_weather_data("t999")
+        result = parse_weather_data("t999")
         self.assertEqual(expected, result)
 
     def test_rain_1h(self):
         expected = "", {
             "rain_1h": 0.0
         }
-        result = _parse_weather_data("r000")
+        result = parse_weather_data("r000")
         self.assertEqual(expected, result)
 
         expected = "", {
             "rain_1h": float(999 * mm_multiplier)
         }
-        result = _parse_weather_data("r999")
+        result = parse_weather_data("r999")
         self.assertEqual(expected, result)
 
     def test_rain_24h(self):
         expected = "", {
             "rain_24h": 0.0
         }
-        result = _parse_weather_data("p000")
+        result = parse_weather_data("p000")
         self.assertEqual(expected, result)
 
         expected = "", {
             "rain_24h": float(999 * mm_multiplier)
         }
-        result = _parse_weather_data("p999")
+        result = parse_weather_data("p999")
         self.assertEqual(expected, result)
 
     def test_rain_since_midnight(self):
         expected = "", {
             "rain_since_midnight": 0.0
         }
-        result = _parse_weather_data("P000")
+        result = parse_weather_data("P000")
         self.assertEqual(expected, result)
 
         expected = "", {
             "rain_since_midnight": float(999 * mm_multiplier)
         }
-        result = _parse_weather_data("P999")
+        result = parse_weather_data("P999")
         self.assertEqual(expected, result)
 
     def test_humidity(self):
         expected = "", {
             "humidity": 0.0
         }
-        result = _parse_weather_data("h00")
+        result = parse_weather_data("h00")
         self.assertEqual(expected, result)
 
         expected = "", {
             "humidity": 99
         }
-        result = _parse_weather_data("h99")
+        result = parse_weather_data("h99")
         self.assertEqual(expected, result)
 
     def test_pressure(self):
         expected = "", {
             "pressure": 0.0
         }
-        result = _parse_weather_data("b00000")
+        result = parse_weather_data("b00000")
         self.assertEqual(expected, result)
 
         expected = "", {
             "pressure": 9999.9
         }
-        result = _parse_weather_data("b99999")
+        result = parse_weather_data("b99999")
         self.assertEqual(expected, result)
 
     def test_luminosity(self):
         expected = "", {
             "luminosity": 000
         }
-        result = _parse_weather_data("L000")
+        result = parse_weather_data("L000")
         self.assertEqual(expected, result)
 
         expected = "", {
             "luminosity": 999
         }
-        result = _parse_weather_data("L999")
+        result = parse_weather_data("L999")
         self.assertEqual(expected, result)
 
         expected = "", {
             "luminosity": 1123
         }
-        result = _parse_weather_data("l123")
+        result = parse_weather_data("l123")
         self.assertEqual(expected, result)
 
         expected = "", {
             "luminosity": 1999
         }
-        result = _parse_weather_data("l999")
+        result = parse_weather_data("l999")
         self.assertEqual(expected, result)
 
     def test_snow(self):
         expected = "", {
             "snow": 000
         }
-        result = _parse_weather_data("s...s000")
+        result = parse_weather_data("s...s000")
         self.assertEqual(expected, result)
 
         expected = "", {
             "snow": float(5.5 * 25.4)
         }
-        result = _parse_weather_data("s...s5.5")
+        result = parse_weather_data("s...s5.5")
         self.assertEqual(expected, result)
 
         expected = "", {
             "snow": float(999 * 25.4)
         }
-        result = _parse_weather_data("s...s999")
+        result = parse_weather_data("s...s999")
         self.assertEqual(expected, result)
 
     def test_rain_raw(self):
         expected = "", {
             "rain_raw": 000
         }
-        result = _parse_weather_data("#000")
+        result = parse_weather_data("#000")
         self.assertEqual(expected, result)
 
         expected = "", {
             "rain_raw": 999
         }
-        result = _parse_weather_data("#999")
+        result = parse_weather_data("#999")
         self.assertEqual(expected, result)
 
     # Not possible in real world (rain and snow measurements)
@@ -253,7 +253,7 @@ class ParseCommentWeather(unittest.TestCase):
             "wind_speed": 1 * wind_multiplier
         }
 
-        result = _parse_weather_data("319/001g004t048r...p   P000h19b10294eCumulusWMR100")
+        result = parse_weather_data("319/001g004t048r...p   P000h19b10294eCumulusWMR100")
         self.assertEqual(expected, result)
 
 if __name__ == '__main__':