remove underscore from util functions

Author: Kareem Zidane

src/cs50/_session.py

@@ -4,20 +4,20 @@
 import sqlalchemy.orm
 
 from ._session_util import (
-    _is_sqlite_url,
-    _assert_sqlite_file_exists,
-    _create_session,
+    is_sqlite_url,
+    assert_sqlite_file_exists,
+    create_session,
 )
 
 
 class Session:
     """Wraps a SQLAlchemy scoped session"""
 
     def __init__(self, url, **engine_kwargs):
-        if _is_sqlite_url(url):
-            _assert_sqlite_file_exists(url)
+        if is_sqlite_url(url):
+            assert_sqlite_file_exists(url)
 
-        self._session = _create_session(url, **engine_kwargs)
+        self._session = create_session(url, **engine_kwargs)
 
     def execute(self, statement):
         """Converts statement to str and executes it"""

src/cs50/_session_util.py

@@ -5,19 +5,19 @@
 
 import sqlalchemy
 
-def _is_sqlite_url(url):
+def is_sqlite_url(url):
     return url.startswith("sqlite:///")
 
 
-def _assert_sqlite_file_exists(url):
+def assert_sqlite_file_exists(url):
     path = url[len("sqlite:///"):]
     if not os.path.exists(path):
         raise RuntimeError(f"does not exist: {path}")
     if not os.path.isfile(path):
         raise RuntimeError(f"not a file: {path}")
 
 
-def _create_session(url, **engine_kwargs):
+def create_session(url, **engine_kwargs):
     engine = _create_engine(url, **engine_kwargs)
     _setup_on_connect(engine)
     return _create_scoped_session(engine)

src/cs50/_statement.py

@@ -4,14 +4,14 @@
 
 from ._sql_sanitizer import SQLSanitizer, escape_verbatim_colon
 from ._statement_util import (
-    _format_and_parse,
-    _get_human_readable_list,
-    _is_identifier,
-    _is_operation_token,
-    _is_placeholder,
-    _is_string_literal,
-    _Paramstyle,
-    _parse_placeholder,
+    format_and_parse,
+    get_human_readable_list,
+    is_identifier,
+    is_operation_token,
+    is_placeholder,
+    is_string_literal,
+    Paramstyle,
+    parse_placeholder,
 )
 
 
@@ -27,7 +27,7 @@ def __init__(self, dialect, sql, *args, **kwargs):
         self._args = self._get_escaped_args(args)
         self._kwargs = self._get_escaped_kwargs(kwargs)
 
-        self._statement = _format_and_parse(sql)
+        self._statement = format_and_parse(sql)
         self._tokens = self._tokenize()
 
         self._operation_keyword = self._get_operation_keyword()
@@ -48,7 +48,7 @@ def _tokenize(self):
 
     def _get_operation_keyword(self):
         for token in self._statement:
-            if _is_operation_token(token.ttype):
+            if is_operation_token(token.ttype):
                 token_value = token.value.upper()
                 if token_value in {"BEGIN", "DELETE", "INSERT", "SELECT", "START", "UPDATE"}:
                     operation_keyword = token_value
@@ -61,8 +61,8 @@ def _get_operation_keyword(self):
     def _get_paramstyle(self):
         paramstyle = None
         for token in self._tokens:
-            if _is_placeholder(token.ttype):
-                paramstyle, _ = _parse_placeholder(token.value)
+            if is_placeholder(token.ttype):
+                paramstyle, _ = parse_placeholder(token.value)
                 break
         else:
             paramstyle = self._default_paramstyle()
@@ -72,17 +72,17 @@ def _get_paramstyle(self):
     def _default_paramstyle(self):
         paramstyle = None
         if self._args:
-            paramstyle = _Paramstyle.QMARK
+            paramstyle = Paramstyle.QMARK
         elif self._kwargs:
-            paramstyle = _Paramstyle.NAMED
+            paramstyle = Paramstyle.NAMED
 
         return paramstyle
 
     def _get_placeholders(self):
         placeholders = collections.OrderedDict()
         for index, token in enumerate(self._tokens):
-            if _is_placeholder(token.ttype):
-                paramstyle, name = _parse_placeholder(token.value)
+            if is_placeholder(token.ttype):
+                paramstyle, name = parse_placeholder(token.value)
                 if paramstyle != self._paramstyle:
                     raise RuntimeError("inconsistent paramstyle")
 
@@ -91,11 +91,11 @@ def _get_placeholders(self):
         return placeholders
 
     def _plugin_escaped_params(self):
-        if self._paramstyle in {_Paramstyle.FORMAT, _Paramstyle.QMARK}:
+        if self._paramstyle in {Paramstyle.FORMAT, Paramstyle.QMARK}:
             self._plugin_format_or_qmark_params()
-        elif self._paramstyle == _Paramstyle.NUMERIC:
+        elif self._paramstyle == Paramstyle.NUMERIC:
             self._plugin_numeric_params()
-        if self._paramstyle in {_Paramstyle.NAMED, _Paramstyle.PYFORMAT}:
+        if self._paramstyle in {Paramstyle.NAMED, Paramstyle.PYFORMAT}:
             self._plugin_named_or_pyformat_params()
 
     def _plugin_format_or_qmark_params(self):
@@ -105,8 +105,8 @@ def _plugin_format_or_qmark_params(self):
 
     def _assert_valid_arg_count(self):
         if len(self._placeholders) != len(self._args):
-            placeholders = _get_human_readable_list(self._placeholders.values())
-            args = _get_human_readable_list(self._args)
+            placeholders = get_human_readable_list(self._placeholders.values())
+            args = get_human_readable_list(self._args)
             if len(self._placeholders) < len(self._args):
                 raise RuntimeError(f"fewer placeholders ({placeholders}) than values ({args})")
 
@@ -122,7 +122,7 @@ def _plugin_numeric_params(self):
             unused_arg_indices.remove(num)
 
         if len(unused_arg_indices) > 0:
-            unused_args = _get_human_readable_list(
+            unused_args = get_human_readable_list(
                 [self._args[i] for i in sorted(unused_arg_indices)])
             raise RuntimeError(
                 f"unused value{'' if len(unused_args) == 1 else 's'} ({unused_args})")
@@ -137,13 +137,13 @@ def _plugin_named_or_pyformat_params(self):
             unused_params.remove(param_name)
 
         if len(unused_params) > 0:
-            joined_unused_params = _get_human_readable_list(sorted(unused_params))
+            joined_unused_params = get_human_readable_list(sorted(unused_params))
             raise RuntimeError(
                 f"unused value{'' if len(unused_params) == 1 else 's'} ({joined_unused_params})")
 
     def _escape_verbatim_colons(self):
         for token in self._tokens:
-            if _is_string_literal(token.ttype) or _is_identifier(token.ttype):
+            if is_string_literal(token.ttype) or is_identifier(token.ttype):
                 token.value = escape_verbatim_colon(token.value)
 
     def get_operation_keyword(self):

src/cs50/_statement_util.py

@@ -6,15 +6,15 @@
 import sqlparse
 
 
-class _Paramstyle(enum.Enum):
+class Paramstyle(enum.Enum):
     FORMAT = enum.auto()
     NAMED = enum.auto()
     NUMERIC = enum.auto()
     PYFORMAT = enum.auto()
     QMARK = enum.auto()
 
 
-def _format_and_parse(sql):
+def format_and_parse(sql):
     formatted_statements = sqlparse.format(sql, strip_comments=True).strip()
     parsed_statements = sqlparse.parse(formatted_statements)
     statement_count = len(parsed_statements)
@@ -26,47 +26,47 @@ def _format_and_parse(sql):
     return parsed_statements[0]
 
 
-def _is_placeholder(ttype):
+def is_placeholder(ttype):
     return ttype == sqlparse.tokens.Name.Placeholder
 
 
-def _parse_placeholder(value):
+def parse_placeholder(value):
     if value == "?":
-        return _Paramstyle.QMARK, None
+        return Paramstyle.QMARK, None
 
     # E.g., :1
     matches = re.search(r"^:([1-9]\d*)$", value)
     if matches:
-        return _Paramstyle.NUMERIC, int(matches.group(1)) - 1
+        return Paramstyle.NUMERIC, int(matches.group(1)) - 1
 
     # E.g., :foo
     matches = re.search(r"^:([a-zA-Z]\w*)$", value)
     if matches:
-        return _Paramstyle.NAMED, matches.group(1)
+        return Paramstyle.NAMED, matches.group(1)
 
     if value == "%s":
-        return _Paramstyle.FORMAT, None
+        return Paramstyle.FORMAT, None
 
     # E.g., %(foo)s
     matches = re.search(r"%\((\w+)\)s$", value)
     if matches:
-        return _Paramstyle.PYFORMAT, matches.group(1)
+        return Paramstyle.PYFORMAT, matches.group(1)
 
     raise RuntimeError(f"{value}: invalid placeholder")
 
 
-def _is_operation_token(ttype):
+def is_operation_token(ttype):
     return ttype in {
         sqlparse.tokens.Keyword, sqlparse.tokens.Keyword.DDL, sqlparse.tokens.Keyword.DML}
 
 
-def _is_string_literal(ttype):
+def is_string_literal(ttype):
     return ttype in [sqlparse.tokens.Literal.String, sqlparse.tokens.Literal.String.Single]
 
 
-def _is_identifier(ttype):
+def is_identifier(ttype):
     return ttype == sqlparse.tokens.Literal.String.Symbol
 
 
-def _get_human_readable_list(iterable):
+def get_human_readable_list(iterable):
     return ", ".join(str(v) for v in iterable)