Merge pull request #6 from ctomkow/rename_api_calls

api method renaming

Author: ctomkow

README.md

@@ -42,46 +42,46 @@ data = [
 ]
 
 
-parser.key(data, 'chain')
+parser.find_key(data, 'chain')
 ['B', 'A']
 
-parser.key(data, 'key')
+parser.find_key(data, 'key')
 [{'chain': 'B'}, {'chain': 'A', 'rope': 5, 'string': 1.2, 'cable': False}, 2, 1]
 
 
-parser.key_chain(data, ['my', 'key', 'chain'])
+parser.find_key_chain(data, ['my', 'key', 'chain'])
 ['A']
 
-parser.key_chain(data, ['key'])
+parser.find_key_chain(data, ['key'])
 [1, 2]
 
-parser.key_chain(data, ['*', 'key', 'chain'])
+parser.find_key_chain(data, ['*', 'key', 'chain'])
 ['A', 'B']
 
-parser.key_chain(data, ['*', 'key', '*'])
+parser.find_key_chain(data, ['*', 'key', '*'])
 ['A', 5, 1.2, False, 'B']
 
 
-parser.key_value(data, 'cable', False)
+parser.find_key_value(data, 'cable', False)
 [{'chain': 'A', 'rope': 5, 'string': 1.2, 'cable': False}]
 
-parser.key_value(data, 'chain', 'B')
+parser.find_key_value(data, 'chain', 'B')
 [{'chain': 'B'}]
 ```
 ### API
-`key(data: dict | list, key: str) -> list`
+`find_key(data: dict | list, key: str) -> list`
 
 - Provide JSON data as a dictionary or a list, as well as the key as a string
 - Returns a list of values that match the corresponding key.
 
-`key_chain(data: dict | list, keys: list) -> list`
+`find_key_chain(data: dict | list, keys: list) -> list`
 
 - Provide JSON data as a dictionary or a list, as well as a list of keys as strings.
 - Returns a list of values that match the corresponding key chain.
 
     > Wildcard **'*'** can be used as key(s) to match any.
 
-`key_value(data: dict | list, key: str, value: str | int | float | bool) -> list`
+`find_key_value(data: dict | list, key: str, value: str | int | float | bool) -> list`
 
 - Provide JSON data as a dictionary or a list, a key as a string,
   and a value as a string, integer, float, or boolean.

jsonparse/VERSION

@@ -1 +1 @@
-0.7.0
+0.8.0

jsonparse/parser.py

@@ -1,10 +1,6 @@
 # Craig Tomkow
 #
-# Dynamically parse JSON objects via two main methods...
-#
-# key: find all values of one key (stack based)
-# key_chain: find all values of an ordered key chain (queue based)
-# key_value: find all key:value pairs and return the parent set(s)
+# Dynamically parse JSON objects
 
 # python imports
 from typing import Union
@@ -19,13 +15,13 @@ class Parser:
     __init__(stack_trace, queue_trace):
         Returns the Parser object.
 
-    key(data, key):
+    find_key(data, key):
         Returns a list of values that have the corresponding key.
 
-    key_chain(data, keys):
+    find_key_chain(data, keys):
         Returns a list of values that have the corresponding key chain.
 
-    key_value(data, key, value):
+    find_key_value(data, key, value):
         Returns a list of set(s) that contain the key value pair.
     """
 
@@ -49,7 +45,7 @@ def __init__(self,
         self.queue_ref = self._queue_init()
 
     # depth first search for all keys using a STACK
-    def key(self, data: Union[dict, list], key: str) -> list:
+    def find_key(self, data: Union[dict, list], key: str) -> list:
         """
         Search JSON data that consists of key:value pairs for all instances of
         provided key. The data can have complex nested dictionaries and lists.
@@ -92,7 +88,7 @@ def key(self, data: Union[dict, list], key: str) -> list:
         return value_list
 
     # breadth first search for ordered series of keys using a QUEUE
-    def key_chain(self, data: Union[dict, list], keys: list) -> list:
+    def find_key_chain(self, data: Union[dict, list], keys: list) -> list:
         """
         Search JSON data that consists of key:value pairs for the first
         instance of provided key chain. The data can have complex nested
@@ -147,10 +143,10 @@ def key_chain(self, data: Union[dict, list], keys: list) -> list:
 
         return self.queue_ref
 
-    def key_value(self,
-                  data: Union[dict, list],
-                  key: str,
-                  value: Union[str, int, float, bool]) -> list:
+    def find_key_value(self,
+                       data: Union[dict, list],
+                       key: str,
+                       value: Union[str, int, float, bool]) -> list:
         """
         Search JSON data that consists of key:value pairs for all instances of
         provided key and value pair. The parent set that contains the key:value

tests/test_parser.py

@@ -90,54 +90,54 @@ def complex_json(self):
             }
         ]
 
-    def test_key(self, parser, complex_json):
+    def test_find_key(self, parser, complex_json):
 
-        result = parser.key(complex_json, "id")
+        result = parser.find_key(complex_json, "id")
         assert result == [
             '0003', '5004', '5003', '5002', '5001', '1002',
             '1001', '0002', '5005', '5004', '5003', '5002', '5001', '1001',
             '0001', '5007', '5006', '5005', '5004', '5003', '5002', '5001',
             '1004', '1003', '1002', '1001'
         ]
 
-    def test_key_not_found(self, parser, complex_json):
+    def test_find_key_not_found(self, parser, complex_json):
 
-        result = parser.key(complex_json, "key_not_in_data")
+        result = parser.find_key(complex_json, "key_not_in_data")
         assert result == []
 
-    def test_key_empty_key(self, parser, complex_json):
+    def test_find_key_empty_key(self, parser, complex_json):
 
         try:
-            parser.key(
+            parser.find_key(
                 complex_json,
                 ""
             )
         except ValueError:
             assert True
 
-    def test_key_not_str_key(self, parser, complex_json):
+    def test_find_key_not_str_key(self, parser, complex_json):
 
         try:
-            parser.key(
+            parser.find_key(
                 complex_json,
                 5
             )
         except TypeError:
             assert True
 
-    def test_key_not_list_or_dict_data(self, parser):
+    def test_find_key_not_list_or_dict_data(self, parser):
 
         try:
-            parser.key(
+            parser.find_key(
                 "string of data",
                 "string"
             )
         except TypeError:
             assert True
 
-    def test_key_chain(self, parser, complex_json):
+    def test_find_key_chain(self, parser, complex_json):
 
-        result = parser.key_chain(
+        result = parser.find_key_chain(
             complex_json,
             [
                 "batters",
@@ -149,30 +149,30 @@ def test_key_chain(self, parser, complex_json):
             'Regular', 'Chocolate', 'Blueberry', "Devil's Food",
             'Regular', 'Regular', 'Chocolate']
 
-    def test_key_chain_empty_key(self, parser, complex_json):
+    def test_find_key_chain_empty_key(self, parser, complex_json):
 
         try:
-            parser.key_chain(
+            parser.find_key_chain(
                 complex_json,
                 [""]
             )
         except ValueError:
             assert True
 
-    def test_key_chain_not_str_key(self, parser, complex_json):
+    def test_find_key_chain_not_str_key(self, parser, complex_json):
 
         try:
-            parser.key_chain(
+            parser.find_key_chain(
                 complex_json,
                 [5]
             )
         except TypeError:
             assert True
 
-    def test_key_chain_not_list_or_dict_data(self, parser):
+    def test_find_key_chain_not_list_or_dict_data(self, parser):
 
         try:
-            parser.key_chain(
+            parser.find_key_chain(
                 "string of data",
                 [
                     "string",
@@ -183,17 +183,17 @@ def test_key_chain_not_list_or_dict_data(self, parser):
         except TypeError:
             assert True
 
-    def test_key_chain_key_not_found(self, parser, complex_json):
+    def test_find_key_chain_key_not_found(self, parser, complex_json):
 
-        result = parser.key_chain(
+        result = parser.find_key_chain(
                 complex_json,
                 ["key_not_in_data"]
             )
         assert result == []
 
-    def test_key_chain_wildcard(self, parser, complex_json):
+    def test_find_key_chain_wildcard(self, parser, complex_json):
 
-        result = parser.key_chain(
+        result = parser.find_key_chain(
             complex_json,
             [
                 "*",
@@ -204,9 +204,9 @@ def test_key_chain_wildcard(self, parser, complex_json):
                           "5007", "5001", "5002", "5003", "5004", "5005",
                           "5001", "5002", "5003", "5004"]
 
-    def test_key_value(self, parser, complex_json):
+    def test_find_key_value(self, parser, complex_json):
 
-        result = parser.key_value(
+        result = parser.find_key_value(
             complex_json,
             "id",
             "1001"
@@ -216,9 +216,9 @@ def test_key_value(self, parser, complex_json):
                           {'id': '1001', 'type': 'Regular'},
                           {'id': '1001', 'type': 'Regular'}]
 
-    def test_key_value_not_found(self, parser, complex_json):
+    def test_find_key_value_not_found(self, parser, complex_json):
 
-        result = parser.key_value(
+        result = parser.find_key_value(
             complex_json,
             "id",
             5.4