Merge pull request #111 from jpoullet2000/table-qn-helpers

Implements the helper functions for table qualified names

Author: jpoullet2000

Diff for: HISTORY.rst

@@ -2,6 +2,11 @@
 History
 =======
 
+1.0.0 (2019-08-10)
+------------------
+* Adds the helper functions to parse the qualified name
+* Updates the version to 1.x to get some confidence from community as the module is pretty stable now
+
 0.1.8 (2019-08-08)
 ------------------
 * Add support for Atlas' Admin Metrics REST API

Diff for: atlasclient/__init__.py

@@ -1 +1 @@
-__version__ = '0.1.8'
+__version__ = '1.0.0'

Diff for: atlasclient/utils.py

@@ -18,16 +18,22 @@
 except ImportError:
     from logging import Handler
 
+
     class NullHandler(Handler):
         def emit(self, record):
             pass
 
-
 DEFAULT_PORTS = {
     'http': 80,
     'https': 443,
 }
 
+DEFAULT_TABLE_QN_REGEX = re.compile(r"""
+    ^(?P<db_name>.*?)\.(?P<table_name>.*)@(?P<cluster_name>.*?)$
+    """, re.X)
+
+DEFAULT_DB_CLUSTER = 'default'
+
 
 def normalize_underscore_case(name):
     """Normalize an underscore-separated descriptor to something more readable.
@@ -78,6 +84,7 @@ def version_str(version):
     else:
         raise ValueError("Invalid version: %s" % version)
 
+
 def generate_http_basic_token(username, password):
     """
     Generates a HTTP basic token from username and password
@@ -87,6 +94,7 @@ def generate_http_basic_token(username, password):
     token = base64.b64encode('{}:{}'.format(username, password).encode('utf-8')).decode('utf-8')
     return token
 
+
 def generate_base_url(host, protocol=None, port=None):
     matches = re.match(r'^(([^:]+)://)?([^/:]+)(:([^/]+))?', host)
     (_, derived_proto, derived_host, _, derived_port) = matches.groups()
@@ -106,3 +114,65 @@ def generate_base_url(host, protocol=None, port=None):
         'port': str(derived_port),
     }
     return "{protocol}://{host}:{port}".format(**url_params)
+
+
+def parse_table_qualified_name(qualified_name, qn_regex=DEFAULT_TABLE_QN_REGEX):
+    """
+    Parses the Atlas' table qualified name
+    :param qualified_name: Qualified Name of the table
+    :return: A dictionary consisting of database name,
+    table name and cluster name of the table.
+    If database or cluster name not found,
+    then uses the 'atlas_default' as both of them.
+    """
+    def apply_qn_regex(name, table_qn_regex):
+        return table_qn_regex.match(name)
+
+    _regex_result = apply_qn_regex(qualified_name, qn_regex)
+
+    if not _regex_result:
+        qn_regex = re.compile(r"""
+        ^(?P<table_name>.*)@(?P<cluster_name>.*?)$
+        """, re.X)
+        _regex_result = apply_qn_regex(qualified_name, qn_regex)
+
+    if not _regex_result:
+        qn_regex = re.compile(r"""
+        ^(?P<db_name>.*?)\.(?P<table_name>.*)$
+        """, re.X)
+        _regex_result = apply_qn_regex(qualified_name, qn_regex)
+
+    if not _regex_result:
+        qn_regex = re.compile(r"""
+        ^(?P<table_name>.*)$
+        """, re.X)
+        _regex_result = apply_qn_regex(qualified_name, qn_regex)
+
+    _regex_result = _regex_result.groupdict()
+
+    qn_dict = {
+        'table_name': _regex_result.get('table_name', qualified_name),
+        'db_name': _regex_result.get('db_name', DEFAULT_DB_CLUSTER),
+        'cluster_name': _regex_result.get('cluster_name', DEFAULT_DB_CLUSTER),
+    }
+
+    return qn_dict
+
+
+def make_table_qualified_name(table_name, cluster=None, db=None):
+    """
+    Based on the given parameters, generate the Atlas' table qualified Name
+    :param db: Database Name of the table
+    :param table_name: Table Name
+    :param cluster: Cluster Name of the table
+    :return: A string i.e., Qualified Name of the table
+    If database or cluster name are 'atlas_default', then simply strips that part.
+    """
+    qualified_name = table_name
+    if db and db != DEFAULT_DB_CLUSTER:
+        qualified_name = '{}.{}'.format(db, qualified_name)
+
+    if cluster and cluster != DEFAULT_DB_CLUSTER:
+        qualified_name = '{}@{}'.format(qualified_name, cluster)
+
+    return qualified_name

Diff for: docs/index.rst

@@ -14,6 +14,7 @@ Contents:
    installation
    readme
    usage
+   utils
    authors
    contributing
    history

Diff for: docs/utils.rst

@@ -0,0 +1,51 @@
+=================
+Utility / Helpers
+=================
+
+
+parse_table_qualified_name()
+----------------------------
+`atlasclient` provides helper function to parse the table qualified name and returns a dictionary
+containing `db_name`, `table_name` and `cluster_name` as keys::
+
+    from atlasclient.utils import parse_table_qualified_name
+
+    # Happy Scenario
+    qualified_name = 'database.table@cluster'
+    qn_dict = parse_table_qualified_name(qualified_name)
+    print(qn_dict["db_name"])
+    # Output: database
+
+    print(qn_dict["table_name"])
+    # Output: table
+
+    print(qn_dict["cluster_name"])
+    # Output: cluster
+
+
+In case if the entity is created manually and somehow does not fully satisfies the atlas qualified name
+pattern, this helper function handles the edge cases::
+
+    qualified_name = 'table@cluster'
+    qn_dict = parse_table_qualified_name(qualified_name)
+    print(qn_dict["db_name"])
+    # Output: default
+
+    print(qn_dict["table_name"])
+    # Output: table
+
+    print(qn_dict["cluster_name"])
+    # Output: cluster
+
+make_table_qualified_name()
+----------------------------
+There is also a function to make the table qualified name, back from the parsed result.
+It verifies if all three i.e., `table_name`, `cluster` and `db` parameters are there and not `default`.
+If the value is default or not available, then this helper handles the edge case accordingly::
+
+    from atlasclient.utils import make_table_qualified_name
+
+    # Happy Scenario
+    qualified_name = make_table_qualified_name('table', 'cluster', 'database')
+    print(qualified_name)
+    # Output: 'database.table@cluster'

Diff for: setup.py

@@ -31,7 +31,6 @@
 with open(setup_requirements_path) as setup_requirements_file:
     setup_requirements = setup_requirements_file.readlines()
 
-setup_args = {}
 setup_args = dict(
     name='atlasclient',
     version=version,
@@ -59,7 +58,6 @@
     ],
     test_suite='tests',
     tests_require=test_requirements,
-    #setup_requires=setup_requirements,
 )
 
 setup(**setup_args)

Diff for: tests/test_utils.py

@@ -0,0 +1,64 @@
+from atlasclient.utils import (parse_table_qualified_name, make_table_qualified_name,
+                               DEFAULT_DB_CLUSTER)
+
+DB = 'database_name'
+CL = 'cluster_name'
+TB = 'table_name'
+
+
+class TestUtils():
+    def test_parse_table_qn(self):
+        qualified_name = '{}.{}@{}'.format(DB, TB, CL)
+        qn_dict = parse_table_qualified_name(qualified_name)
+        assert qn_dict['db_name'] == DB
+        assert qn_dict['cluster_name'] == CL
+        assert qn_dict['table_name'] == TB
+
+    def test_parse_table_qn_without_db(self):
+        qualified_name = '{}@{}'.format(TB, CL)
+        qn_dict = parse_table_qualified_name(qualified_name)
+        assert qn_dict['db_name'] == DEFAULT_DB_CLUSTER
+        assert qn_dict['cluster_name'] == CL
+        assert qn_dict['table_name'] == TB
+
+    def test_parse_table_qn_without_cluster(self):
+        qualified_name = '{}.{}'.format(DB, TB)
+        qn_dict = parse_table_qualified_name(qualified_name)
+        assert qn_dict['db_name'] == DB
+        assert qn_dict['cluster_name'] == DEFAULT_DB_CLUSTER
+        assert qn_dict['table_name'] == TB
+
+    def test_parse_table_qn_only_table(self):
+        qualified_name = '{}'.format(TB)
+        qn_dict = parse_table_qualified_name(qualified_name)
+        assert qn_dict['db_name'] == DEFAULT_DB_CLUSTER
+        assert qn_dict['cluster_name'] == DEFAULT_DB_CLUSTER
+        assert qn_dict['table_name'] == TB
+
+    def test_make_table_qn(self):
+        qn = make_table_qualified_name(TB, CL, DB)
+        assert qn == '{}.{}@{}'.format(DB, TB, CL)
+
+    def test_make_table_qn_with_default_database(self):
+        qn = make_table_qualified_name(TB, CL, DEFAULT_DB_CLUSTER)
+        assert qn == '{}@{}'.format(TB, CL)
+
+    def test_make_table_qn_with_default_cluster(self):
+        qn = make_table_qualified_name(TB, DEFAULT_DB_CLUSTER, DB)
+        assert qn == '{}.{}'.format(DB, TB)
+
+    def test_make_table_qn_only_table_with_default_db_cluster(self):
+        qn = make_table_qualified_name(TB, DEFAULT_DB_CLUSTER, DEFAULT_DB_CLUSTER)
+        assert qn == '{}'.format(TB)
+
+    def test_make_table_qn_without_database(self):
+        qn = make_table_qualified_name(TB, CL)
+        assert qn == '{}@{}'.format(TB, CL)
+
+    def test_make_table_qn_without_cluster(self):
+        qn = make_table_qualified_name(TB, db=DB)
+        assert qn == '{}.{}'.format(DB, TB)
+
+    def test_make_table_qn_only_table(self):
+        qn = make_table_qualified_name(TB)
+        assert qn == '{}'.format(TB)