[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]

[tor-commits] [stem/master] Marking stem.util.str_tools functions as being private



commit aab3bf57a87bb09d4d572195e568e73da489f38a
Author: Damian Johnson <atagar@xxxxxxxxxxxxxx>
Date:   Sat Mar 9 23:07:23 2013 -0800

    Marking stem.util.str_tools functions as being private
    
    Swapping several of the functions that we don't want to vend as being private.
    The to_bytes() and to_unicode() functions in particular are simply there for
    python 3.x support, so they'll disappear if/when we drop python 2.x support.
---
 stem/connection.py                        |    8 ++++----
 stem/descriptor/__init__.py               |    8 ++++----
 stem/descriptor/extrainfo_descriptor.py   |    2 +-
 stem/descriptor/networkstatus.py          |    4 ++--
 stem/descriptor/router_status_entry.py    |    2 +-
 stem/descriptor/server_descriptor.py      |    6 +++---
 stem/response/authchallenge.py            |    4 ++--
 stem/response/events.py                   |    4 ++--
 stem/socket.py                            |    6 +++---
 stem/util/enum.py                         |    2 +-
 stem/util/str_tools.py                    |   27 +++++++++++----------------
 stem/util/system.py                       |    2 +-
 stem/util/term.py                         |    2 +-
 test/settings.cfg                         |    4 ++--
 test/unit/descriptor/server_descriptor.py |    2 +-
 test/unit/util/str_tools.py               |   22 +++++++++++-----------
 16 files changed, 50 insertions(+), 55 deletions(-)

diff --git a/stem/connection.py b/stem/connection.py
index dc70bce..4f63378 100644
--- a/stem/connection.py
+++ b/stem/connection.py
@@ -596,8 +596,8 @@ def authenticate_cookie(controller, cookie_path, suppress_ctl_errors = True):
     # This seems dumb but oh well. Converting the result to unicode so it won't
     # misbehave.
 
-    auth_token_hex = binascii.b2a_hex(stem.util.str_tools.to_bytes(cookie_data))
-    msg = "AUTHENTICATE %s" % stem.util.str_tools.to_unicode(auth_token_hex)
+    auth_token_hex = binascii.b2a_hex(stem.util.str_tools._to_bytes(cookie_data))
+    msg = "AUTHENTICATE %s" % stem.util.str_tools._to_unicode(auth_token_hex)
     auth_response = _msg(controller, msg)
 
     # if we got anything but an OK response then error
@@ -692,7 +692,7 @@ def authenticate_safecookie(controller, cookie_path, suppress_ctl_errors = True)
   client_nonce = os.urandom(32)
 
   try:
-    client_nonce_hex = binascii.b2a_hex(stem.util.str_tools.to_bytes(client_nonce))
+    client_nonce_hex = binascii.b2a_hex(stem.util.str_tools._to_bytes(client_nonce))
     authchallenge_response = _msg(controller, "AUTHCHALLENGE SAFECOOKIE %s" % client_nonce_hex)
 
     if not authchallenge_response.is_ok():
@@ -744,7 +744,7 @@ def authenticate_safecookie(controller, cookie_path, suppress_ctl_errors = True)
       CLIENT_HASH_CONSTANT,
       cookie_data + client_nonce + authchallenge_response.server_nonce)
 
-    auth_response = _msg(controller, "AUTHENTICATE %s" % (binascii.b2a_hex(stem.util.str_tools.to_bytes(client_hash))))
+    auth_response = _msg(controller, "AUTHENTICATE %s" % (binascii.b2a_hex(stem.util.str_tools._to_bytes(client_hash))))
   except stem.ControllerError, exc:
     try:
       controller.connect()
diff --git a/stem/descriptor/__init__.py b/stem/descriptor/__init__.py
index 59d66a4..4f0a596 100644
--- a/stem/descriptor/__init__.py
+++ b/stem/descriptor/__init__.py
@@ -307,7 +307,7 @@ class Descriptor(object):
     if stem.prereq.is_python_3():
       return self._raw_contents
     else:
-      return str(stem.util.str_tools.to_bytes(self._raw_contents))
+      return str(stem.util.str_tools._to_bytes(self._raw_contents))
 
 
 class _UnicodeReader(object):
@@ -333,10 +333,10 @@ class _UnicodeReader(object):
     return self.wrapped_file.next()
 
   def read(self, n = -1):
-    return stem.util.str_tools.to_unicode(self.wrapped_file.read(n))
+    return stem.util.str_tools._to_unicode(self.wrapped_file.read(n))
 
   def readline(self):
-    return stem.util.str_tools.to_unicode(self.wrapped_file.readline())
+    return stem.util.str_tools._to_unicode(self.wrapped_file.readline())
 
   def readlines(self, sizehint = None):
     # being careful to do in-place conversion so we don't accidently double our
@@ -348,7 +348,7 @@ class _UnicodeReader(object):
       results = self.wrapped_file.readlines()
 
     for i in xrange(len(results)):
-      results[i] = stem.util.str_tools.to_unicode(results[i])
+      results[i] = stem.util.str_tools._to_unicode(results[i])
 
     return results
 
diff --git a/stem/descriptor/extrainfo_descriptor.py b/stem/descriptor/extrainfo_descriptor.py
index 3d7bb3c..5f1c423 100644
--- a/stem/descriptor/extrainfo_descriptor.py
+++ b/stem/descriptor/extrainfo_descriptor.py
@@ -825,7 +825,7 @@ class RelayExtraInfoDescriptor(ExtraInfoDescriptor):
       # our digest is calculated from everything except our signature
       raw_content, ending = str(self), "\nrouter-signature\n"
       raw_content = raw_content[:raw_content.find(ending) + len(ending)]
-      self._digest = hashlib.sha1(stem.util.str_tools.to_bytes(raw_content)).hexdigest().upper()
+      self._digest = hashlib.sha1(stem.util.str_tools._to_bytes(raw_content)).hexdigest().upper()
 
     return self._digest
 
diff --git a/stem/descriptor/networkstatus.py b/stem/descriptor/networkstatus.py
index e032f76..de0b945 100644
--- a/stem/descriptor/networkstatus.py
+++ b/stem/descriptor/networkstatus.py
@@ -265,7 +265,7 @@ class NetworkStatusDocumentV2(NetworkStatusDocument):
   """
 
   def __init__(self, raw_content, validate = True):
-    raw_content = stem.util.str_tools.to_unicode(raw_content)
+    raw_content = stem.util.str_tools._to_unicode(raw_content)
     super(NetworkStatusDocumentV2, self).__init__(raw_content)
 
     self.version = None
@@ -464,7 +464,7 @@ class NetworkStatusDocumentV3(NetworkStatusDocument):
     :raises: **ValueError** if the document is invalid
     """
 
-    raw_content = stem.util.str_tools.to_unicode(raw_content)
+    raw_content = stem.util.str_tools._to_unicode(raw_content)
     super(NetworkStatusDocumentV3, self).__init__(raw_content)
     document_file = StringIO.StringIO(raw_content)
 
diff --git a/stem/descriptor/router_status_entry.py b/stem/descriptor/router_status_entry.py
index ef810ec..68c1b38 100644
--- a/stem/descriptor/router_status_entry.py
+++ b/stem/descriptor/router_status_entry.py
@@ -703,7 +703,7 @@ def _decode_fingerprint(identity, validate):
   fingerprint = ""
 
   try:
-    identity_decoded = base64.b64decode(stem.util.str_tools.to_bytes(identity))
+    identity_decoded = base64.b64decode(stem.util.str_tools._to_bytes(identity))
   except (TypeError, binascii.Error):
     if not validate:
       return None
diff --git a/stem/descriptor/server_descriptor.py b/stem/descriptor/server_descriptor.py
index 298b480..89795c9 100644
--- a/stem/descriptor/server_descriptor.py
+++ b/stem/descriptor/server_descriptor.py
@@ -665,7 +665,7 @@ class RelayDescriptor(ServerDescriptor):
 
       if start >= 0 and sig_start > 0 and end > start:
         for_digest = raw_descriptor[start:end]
-        digest_hash = hashlib.sha1(stem.util.str_tools.to_bytes(for_digest))
+        digest_hash = hashlib.sha1(stem.util.str_tools._to_bytes(for_digest))
         self._digest = digest_hash.hexdigest().upper()
       else:
         raise ValueError("unable to calculate digest for descriptor")
@@ -686,7 +686,7 @@ class RelayDescriptor(ServerDescriptor):
     if self.fingerprint:
       # calculate the signing key hash
 
-      key_der_as_hash = hashlib.sha1(stem.util.str_tools.to_bytes(key_as_bytes)).hexdigest()
+      key_der_as_hash = hashlib.sha1(stem.util.str_tools._to_bytes(key_as_bytes)).hexdigest()
 
       if key_der_as_hash != self.fingerprint.lower():
         log.warn("Signing key hash: %s != fingerprint: %s" % (key_der_as_hash, self.fingerprint.lower()))
@@ -821,7 +821,7 @@ class RelayDescriptor(ServerDescriptor):
 
     # get the key representation in bytes
 
-    key_bytes = base64.b64decode(stem.util.str_tools.to_bytes(key_as_string))
+    key_bytes = base64.b64decode(stem.util.str_tools._to_bytes(key_as_string))
 
     return key_bytes
 
diff --git a/stem/response/authchallenge.py b/stem/response/authchallenge.py
index c14369b..93be385 100644
--- a/stem/response/authchallenge.py
+++ b/stem/response/authchallenge.py
@@ -41,7 +41,7 @@ class AuthChallengeResponse(stem.response.ControlMessage):
       if not stem.util.tor_tools.is_hex_digits(value, 64):
         raise stem.ProtocolError("SERVERHASH has an invalid value: %s" % value)
 
-      self.server_hash = binascii.a2b_hex(stem.util.str_tools.to_bytes(value))
+      self.server_hash = binascii.a2b_hex(stem.util.str_tools._to_bytes(value))
     else:
       raise stem.ProtocolError("Missing SERVERHASH mapping: %s" % line)
 
@@ -51,6 +51,6 @@ class AuthChallengeResponse(stem.response.ControlMessage):
       if not stem.util.tor_tools.is_hex_digits(value, 64):
         raise stem.ProtocolError("SERVERNONCE has an invalid value: %s" % value)
 
-      self.server_nonce = binascii.a2b_hex(stem.util.str_tools.to_bytes(value))
+      self.server_nonce = binascii.a2b_hex(stem.util.str_tools._to_bytes(value))
     else:
       raise stem.ProtocolError("Missing SERVERNONCE mapping: %s" % line)
diff --git a/stem/response/events.py b/stem/response/events.py
index af8c8e5..a2c43ff 100644
--- a/stem/response/events.py
+++ b/stem/response/events.py
@@ -345,7 +345,7 @@ class CircuitEvent(Event):
 
     if self.created is not None:
       try:
-        self.created = str_tools.parse_iso_timestamp(self.created)
+        self.created = str_tools._parse_iso_timestamp(self.created)
       except ValueError, exc:
         raise stem.ProtocolError("Unable to parse create date (%s): %s" % (exc, self))
 
@@ -401,7 +401,7 @@ class CircMinorEvent(Event):
 
     if self.created is not None:
       try:
-        self.created = str_tools.parse_iso_timestamp(self.created)
+        self.created = str_tools._parse_iso_timestamp(self.created)
       except ValueError, exc:
         raise stem.ProtocolError("Unable to parse create date (%s): %s" % (exc, self))
 
diff --git a/stem/socket.py b/stem/socket.py
index 3b9498c..d459fb7 100644
--- a/stem/socket.py
+++ b/stem/socket.py
@@ -425,7 +425,7 @@ def send_message(control_file, message, raw = False):
     message = send_formatting(message)
 
   try:
-    control_file.write(stem.util.str_tools.to_bytes(message))
+    control_file.write(stem.util.str_tools._to_bytes(message))
     control_file.flush()
 
     log_message = message.replace("\r\n", "\n").rstrip()
@@ -473,7 +473,7 @@ def recv_message(control_file):
       line = control_file.readline()
 
       if stem.prereq.is_python_3():
-        line = stem.util.str_tools.to_unicode(line)
+        line = stem.util.str_tools._to_unicode(line)
     except AttributeError:
       # if the control_file has been closed then we will receive:
       # AttributeError: 'NoneType' object has no attribute 'recv'
@@ -542,7 +542,7 @@ def recv_message(control_file):
           line = control_file.readline()
 
           if stem.prereq.is_python_3():
-            line = stem.util.str_tools.to_unicode(line)
+            line = stem.util.str_tools._to_unicode(line)
         except socket.error, exc:
           prefix = logging_prefix % "SocketClosed"
           log.info(prefix + "received an exception while mid-way through a data reply (exception: \"%s\", read content: \"%s\")" % (exc, log.escape(raw_content)))
diff --git a/stem/util/enum.py b/stem/util/enum.py
index bd983ee..504af48 100644
--- a/stem/util/enum.py
+++ b/stem/util/enum.py
@@ -75,7 +75,7 @@ class Enum(object):
 
     for entry in args:
       if isinstance(entry, str):
-        key, val = entry, stem.util.str_tools.to_camel_case(entry)
+        key, val = entry, stem.util.str_tools._to_camel_case(entry)
       elif isinstance(entry, tuple) and len(entry) == 2:
         key, val = entry
       else:
diff --git a/stem/util/str_tools.py b/stem/util/str_tools.py
index 14198b4..d575cfa 100644
--- a/stem/util/str_tools.py
+++ b/stem/util/str_tools.py
@@ -8,16 +8,11 @@ Toolkit for various string activity.
 
 ::
 
-  to_bytes - normalizes string ASCII bytes
-  to_unicode - normalizes string to unicode
-  to_camel_case - converts a string to camel case
   get_size_label - human readable label for a number of bytes
   get_time_label - human readable label for a number of seconds
   get_time_labels - human readable labels for each time unit
   get_short_time_label - condensed time label output
   parse_short_time_label - seconds represented by a short time label
-
-  parse_iso_timestamp - parses an ISO timestamp as a datetime value
 """
 
 import codecs
@@ -53,32 +48,32 @@ TIME_UNITS = (
 )
 
 if stem.prereq.is_python_3():
-  def _to_bytes(msg):
+  def _to_bytes_impl(msg):
     if isinstance(msg, str):
       return codecs.latin_1_encode(msg, "replace")[0]
     else:
       return msg
 
-  def _to_unicode(msg):
+  def _to_unicode_impl(msg):
     if msg is not None and not isinstance(msg, str):
       return msg.decode("utf-8", "replace")
     else:
       return msg
 else:
-  def _to_bytes(msg):
+  def _to_bytes_impl(msg):
     if msg is not None and isinstance(msg, unicode):
       return codecs.latin_1_encode(msg, "replace")[0]
     else:
       return msg
 
-  def _to_unicode(msg):
+  def _to_unicode_impl(msg):
     if msg is not None and not isinstance(msg, unicode):
       return msg.decode("utf-8", "replace")
     else:
       return msg
 
 
-def to_bytes(msg):
+def _to_bytes(msg):
   """
   Provides the ASCII bytes for the given string. This is purely to provide
   python 3 compatability, normalizing the unicode/ASCII change in the version
@@ -91,10 +86,10 @@ def to_bytes(msg):
   :returns: ASCII bytes for string
   """
 
-  return _to_bytes(msg)
+  return _to_bytes_impl(msg)
 
 
-def to_unicode(msg):
+def _to_unicode(msg):
   """
   Provides the unicode string for the given ASCII bytes. This is purely to
   provide python 3 compatability, normalizing the unicode/ASCII change in the
@@ -105,16 +100,16 @@ def to_unicode(msg):
   :returns: unicode conversion
   """
 
-  return _to_unicode(msg)
+  return _to_unicode_impl(msg)
 
 
-def to_camel_case(label, divider = "_", joiner = " "):
+def _to_camel_case(label, divider = "_", joiner = " "):
   """
   Converts the given string to camel case, ie:
 
   ::
 
-    >>> to_camel_case("I_LIKE_PEPPERJACK!")
+    >>> _to_camel_case("I_LIKE_PEPPERJACK!")
     'I Like Pepperjack!'
 
   :param str label: input string to be converted
@@ -315,7 +310,7 @@ def parse_short_time_label(label):
     raise ValueError("Non-numeric value in time entry: %s" % label)
 
 
-def parse_iso_timestamp(entry):
+def _parse_iso_timestamp(entry):
   """
   Parses the ISO 8601 standard that provides for timestamps like...
 
diff --git a/stem/util/system.py b/stem/util/system.py
index 688475f..0a94b57 100644
--- a/stem/util/system.py
+++ b/stem/util/system.py
@@ -814,7 +814,7 @@ def _set_prctl_name(process_name):
 
   libc = ctypes.CDLL(ctypes.util.find_library("c"))
   name_buffer = ctypes.create_string_buffer(len(process_name) + 1)
-  name_buffer.value = stem.util.str_tools.to_bytes(process_name)
+  name_buffer.value = stem.util.str_tools._to_bytes(process_name)
   libc.prctl(PR_SET_NAME, ctypes.byref(name_buffer), 0, 0, 0)
 
 
diff --git a/stem/util/term.py b/stem/util/term.py
index 5f54b5d..05efcfe 100644
--- a/stem/util/term.py
+++ b/stem/util/term.py
@@ -87,7 +87,7 @@ def format(msg, *attr):
 
   encodings = []
   for text_attr in attr:
-    text_attr, encoding = stem.util.str_tools.to_camel_case(text_attr), None
+    text_attr, encoding = stem.util.str_tools._to_camel_case(text_attr), None
     encoding = FG_ENCODING.get(text_attr, encoding)
     encoding = BG_ENCODING.get(text_attr, encoding)
     encoding = ATTR_ENCODING.get(text_attr, encoding)
diff --git a/test/settings.cfg b/test/settings.cfg
index c184eec..8e96214 100644
--- a/test/settings.cfg
+++ b/test/settings.cfg
@@ -158,8 +158,8 @@ pyflakes.ignore stem/prereq.py => 'RSA' imported but unused
 pyflakes.ignore stem/prereq.py => 'asn1' imported but unused
 pyflakes.ignore stem/prereq.py => 'long_to_bytes' imported but unused
 pyflakes.ignore stem/descriptor/__init__.py => redefinition of unused 'OrderedDict' from line 60
-pyflakes.ignore stem/util/str_tools.py => redefinition of function '_to_bytes' from line 56
-pyflakes.ignore stem/util/str_tools.py => redefinition of function '_to_unicode' from line 62
+pyflakes.ignore stem/util/str_tools.py => redefinition of function '_to_bytes_impl' from line 51
+pyflakes.ignore stem/util/str_tools.py => redefinition of function '_to_unicode_impl' from line 57
 pyflakes.ignore test/mocking.py => undefined name 'builtins'
 pyflakes.ignore test/unit/response/events.py => 'from stem import *' used; unable to detect undefined names
 
diff --git a/test/unit/descriptor/server_descriptor.py b/test/unit/descriptor/server_descriptor.py
index 07fb50c..3da01b5 100644
--- a/test/unit/descriptor/server_descriptor.py
+++ b/test/unit/descriptor/server_descriptor.py
@@ -210,7 +210,7 @@ class TestServerDescriptor(unittest.TestCase):
     desc_text += "\ntrailing text that should be ignored, ho hum"
 
     # running _parse_file should provide an iterator with a single descriptor
-    desc_iter = stem.descriptor.server_descriptor._parse_file(StringIO.StringIO(stem.util.str_tools.to_unicode(desc_text)))
+    desc_iter = stem.descriptor.server_descriptor._parse_file(StringIO.StringIO(stem.util.str_tools._to_unicode(desc_text)))
     desc_entries = list(desc_iter)
     self.assertEquals(1, len(desc_entries))
     desc = desc_entries[0]
diff --git a/test/unit/util/str_tools.py b/test/unit/util/str_tools.py
index 4b35278..550edeb 100644
--- a/test/unit/util/str_tools.py
+++ b/test/unit/util/str_tools.py
@@ -11,19 +11,19 @@ from stem.util import str_tools
 class TestStrTools(unittest.TestCase):
   def test_to_camel_case(self):
     """
-    Checks the to_camel_case() function.
+    Checks the _to_camel_case() function.
     """
 
     # test the pydoc example
-    self.assertEquals("I Like Pepperjack!", str_tools.to_camel_case("I_LIKE_PEPPERJACK!"))
+    self.assertEquals("I Like Pepperjack!", str_tools._to_camel_case("I_LIKE_PEPPERJACK!"))
 
     # check a few edge cases
-    self.assertEquals("", str_tools.to_camel_case(""))
-    self.assertEquals("Hello", str_tools.to_camel_case("hello"))
-    self.assertEquals("Hello", str_tools.to_camel_case("HELLO"))
-    self.assertEquals("Hello  World", str_tools.to_camel_case("hello__world"))
-    self.assertEquals("Hello\tworld", str_tools.to_camel_case("hello\tWORLD"))
-    self.assertEquals("Hello\t\tWorld", str_tools.to_camel_case("hello__world", "_", "\t"))
+    self.assertEquals("", str_tools._to_camel_case(""))
+    self.assertEquals("Hello", str_tools._to_camel_case("hello"))
+    self.assertEquals("Hello", str_tools._to_camel_case("HELLO"))
+    self.assertEquals("Hello  World", str_tools._to_camel_case("hello__world"))
+    self.assertEquals("Hello\tworld", str_tools._to_camel_case("hello\tWORLD"))
+    self.assertEquals("Hello\t\tWorld", str_tools._to_camel_case("hello__world", "_", "\t"))
 
   def test_get_size_label(self):
     """
@@ -125,7 +125,7 @@ class TestStrTools(unittest.TestCase):
 
   def test_parse_iso_timestamp(self):
     """
-    Checks the parse_iso_timestamp() function.
+    Checks the _parse_iso_timestamp() function.
     """
 
     test_inputs = {
@@ -138,7 +138,7 @@ class TestStrTools(unittest.TestCase):
     }
 
     for arg, expected in test_inputs.items():
-      self.assertEqual(expected, str_tools.parse_iso_timestamp(arg))
+      self.assertEqual(expected, str_tools._parse_iso_timestamp(arg))
 
     invalid_input = [
       None,
@@ -150,4 +150,4 @@ class TestStrTools(unittest.TestCase):
     ]
 
     for arg in invalid_input:
-      self.assertRaises(ValueError, str_tools.parse_iso_timestamp, arg)
+      self.assertRaises(ValueError, str_tools._parse_iso_timestamp, arg)



_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits