jpcli 0.3.0__tar.gz → 0.5.0__tar.gz

{jpcli-0.3.0/jpcli.egg-info → jpcli-0.5.0}/PKG-INFO

@@ -1,10 +1,12 @@
 Metadata-Version: 2.1
 Name: jpcli
-Version: 0.3.0
+Version: 0.5.0
 Summary: A library to convert Linux command output to JSON
 Home-page: https://github.com/JaimeAdanCuevas/jpcli
 Author: Jaime Cuevas
 Author-email: adancuevas@outlook.com
+License: UNKNOWN
+Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
@@ -21,3 +23,5 @@ jpcli is a library that converts the output of various Linux commands to JSON fo
 ```sh
 pip install jpcli
 
+
+

jpcli-0.5.0/jpcli/parsers/cmdline_parser.py

@@ -0,0 +1,19 @@
+import json
+
+
+def parse(command_output):
+    # Split the command line output into individual parameters
+    params = command_output.strip().split()
+
+    # Create a dictionary to hold the parsed key-value pairs
+    cmdline_dict = {}
+
+    for param in params:
+        if '=' in param:
+            key, value = param.split('=', 1)
+        else:
+            key, value = param, None  # Handle flags with no value (e.g., "quiet")
+        cmdline_dict[key] = value
+
+    # Convert the dictionary to a JSON-formatted string
+    return json.dumps(cmdline_dict, indent=2)

jpcli-0.5.0/jpcli/parsers/cpuinfo_parser.py

@@ -0,0 +1,29 @@
+import json
+
+
+def parse(command_output):
+    processors = []
+    current_processor = {}
+
+    lines = command_output.splitlines()
+    for line in lines:
+        if line.strip():  # Check if line is not empty
+            key, value = line.split(':')
+            key = key.strip().replace(' ', '_').lower()
+            value = value.strip()
+            if key == 'processor' and current_processor:
+                # When a new processor block starts, append the previous one
+                processors.append(current_processor)
+                current_processor = {}
+            current_processor[key] = value
+        else:
+            # Empty line indicates the end of one processor's info
+            if current_processor:
+                processors.append(current_processor)
+                current_processor = {}
+
+    # Append the last processor if exists
+    if current_processor:
+        processors.append(current_processor)
+
+    return json.dumps(processors, indent=2)

{jpcli-0.3.0 → jpcli-0.5.0}/jpcli/parsers/df_parser.py

@@ -1,3 +1,6 @@
+import json
+
+
 def parse(command_output):
     lines = command_output.splitlines()
     data = []
@@ -13,4 +16,4 @@ def parse(command_output):
         entry = {headers[i]: values[i] for i in range(len(headers))}
         data.append(entry)
 
-    return data
+    return json.dumps(data, indent=2)

jpcli-0.5.0/jpcli/parsers/dmesg_parser.py

@@ -0,0 +1,13 @@
+import json
+
+
+def parse(dmesg_output):
+    """
+    Parse the contents of dmesg output.
+    """
+    try:
+        dmesg_lines = dmesg_output.strip().split('\n')
+        dmesg_list = [{"message": line} for line in dmesg_lines]
+        return json.dumps(dmesg_list, indent=2)
+    except Exception as e:
+        return json.dumps({"error": str(e), "message": "Failed to parse dmesg output"}, indent=2)

jpcli-0.5.0/jpcli/parsers/free_parser.py

@@ -0,0 +1,23 @@
+import json
+
+
+def parse(command_output):
+    lines = command_output.strip().split("\n")
+    headers = lines[0].split()
+    memory_data = []
+
+    for line in lines[1:]:
+        values = line.split()
+        category = values[0].strip(":")  # Extract "Mem" or "Swap"
+        values = values[1:]  # Remove category from values
+
+        # Ensure proper key-value matching
+        if len(values) == len(headers):
+            entry = {headers[i]: values[i] for i in range(len(headers))}
+        else:
+            entry = {headers[i]: values[i] if i < len(values) else "N/A" for i in range(len(headers))}
+
+        entry["category"] = category  # Add category name separately
+        memory_data.append(entry)
+
+    return json.dumps(memory_data, indent=2)

{jpcli-0.3.0 → jpcli-0.5.0}/jpcli/parsers/ifconfig_parser.py

@@ -1,4 +1,5 @@
 import re
+import json
 
 
 def parse(ifconfig_output):
@@ -37,4 +38,4 @@ def parse(ifconfig_output):
     if current_interface:
         interfaces[current_interface['name']] = current_interface
 
-    return interfaces
+    return json.dumps(interfaces, indent=2)

jpcli-0.5.0/jpcli/parsers/journalctl_parser.py

@@ -0,0 +1,27 @@
+import json
+
+
+def parse(journalctl_output):
+    """
+    Parse the contents of journalctl output.
+    """
+    try:
+        # Split the output into individual lines
+        journalctl_lines = journalctl_output.strip().split('\n')
+
+        # Initialize a list to store JSON objects
+        journalctl_list = []
+
+        # Process each line
+        for line in journalctl_lines:
+            if line:  # Skip empty lines
+                # Parse each line as JSON and append to the list
+                journalctl_list.append(json.loads(line))
+
+        # Convert the list of JSON objects to a pretty-printed JSON string
+        return json.dumps(journalctl_list, indent=2)
+
+    except json.JSONDecodeError as e:
+        return json.dumps({"error": str(e), "message": "Failed to parse JSON from journalctl output"}, indent=2)
+    except Exception as e:
+        return json.dumps({"error": str(e), "message": "Failed to parse journalctl output"}, indent=2)

{jpcli-0.3.0 → jpcli-0.5.0}/jpcli/parsers/lscpu_parser.py

@@ -1,3 +1,6 @@
+import json
+
+
 def parse(command_output):
     """
     Parses the output of the lscpu command into a dictionary.
@@ -17,17 +20,4 @@ def parse(command_output):
                 key = parts[0].strip()
                 value = parts[1].strip()
                 cpu_info[key] = value
-    return cpu_info
-
-
-def lscpu_parser(command_output):
-    """
-    Wrapper function to parse lscpu output.
-
-    Args:
-    command_output (str): The string output from the lscpu command.
-
-    Returns:
-    dict: Parsed CPU information.
-    """
-    return parse(command_output)
+    return json.dumps(cpu_info, indent=2)

{jpcli-0.3.0 → jpcli-0.5.0}/jpcli/parsers/lshw_parser.py

@@ -1,4 +1,10 @@
-def parse(command_output):
+import json
+
+
+def parse(command_output, indent_level=0):
+    """
+    Recursively parse sections of command output based on indentation level.
+    """
     def parse_section(lines, indent_level):
         data = {}
         current_section = {}  # Initialize as empty dictionary
@@ -6,14 +12,16 @@ def parse(command_output):
             line = lines.pop(0)
             if line.strip() == "":
                 continue  # Ignore empty lines
+
             indent = len(line) - len(line.lstrip())
+
             if indent < indent_level:
                 lines.insert(0, line)
                 break
             elif line.startswith('  *-'):
                 if current_section:
                     yield current_section
-                current_section = {'description': line.split('-')[-1].strip()}  # Initialize here
+                current_section = {'description': line.split('-')[-1].strip()}  # Initialize with description
             elif indent == indent_level and line.startswith('       '):
                 parts = line.strip().split(': ', 1)
                 if len(parts) == 2:
@@ -25,14 +33,10 @@ def parse(command_output):
                     if 'subsections' not in current_section:
                         current_section['subsections'] = []
                     current_section['subsections'].extend(parse_section([line] + lines, indent))
+
         if current_section:
             yield current_section
 
     lines = command_output.splitlines()
-    result = list(parse_section(lines, 0))
-    return result
-
-
-def lshw_parser(command_output):
-    lines = command_output.splitlines()
-    return list(parse_section(lines, 0))
+    parsed_data = list(parse_section(lines, indent_level))
+    return json.dumps(parsed_data, indent=2)

jpcli-0.5.0/jpcli/parsers/lsmem_parser.py

@@ -0,0 +1,34 @@
+import json
+
+
+def parse(command_output):
+    lines = command_output.splitlines()
+    memory_blocks = []
+    headers = []
+    summary = {}
+
+    # Extract headers from the first line
+    if lines:
+        headers = [header.strip() for header in lines[0].split() if header.strip()]
+        lines = lines[1:]
+
+    for line in lines:
+        if not line.strip():  # Skip empty lines
+            continue
+
+        # Check if the line contains summary information
+        if ':' in line:
+            key, value = line.split(':')
+            summary[key.strip().lower().replace(' ', '_')] = value.strip()
+        else:
+            values = [value.strip() for value in line.split() if value.strip()]
+            if len(values) == len(headers):
+                entry = {headers[i].lower(): values[i] for i in range(len(headers))}
+                memory_blocks.append(entry)
+
+    result = {
+        "memory_blocks": memory_blocks,
+        **summary
+    }
+
+    return json.dumps(result, indent=2)

{jpcli-0.3.0 → jpcli-0.5.0}/jpcli/parsers/mcelog_parser.py

@@ -1,3 +1,6 @@
+import json
+
+
 def parse(mcelog_output):
     """
     Parse the contents of mcelog output.
@@ -7,6 +10,6 @@ def parse(mcelog_output):
         mcelog_list = []
         for line in mcelog_lines:
             mcelog_list.append(line)
-        return mcelog_list
+        return json.dumps(mcelog_list, indent=2)
     except Exception as e:
         return {"error": str(e), "message": "Failed to parse mcelog output"}

{jpcli-0.3.0 → jpcli-0.5.0}/jpcli/parsers/os_release_parser.py

@@ -1,4 +1,6 @@
-# jpcli/parsers/os_release_parser.py
+import json
+
+
 def parse(os_release_output):
     """
     Parse the contents of /etc/os-release.
@@ -8,4 +10,4 @@ def parse(os_release_output):
         if '=' in line:
             key, value = line.split('=', 1)
             os_release_dict[key] = value.strip('"')
-    return os_release_dict
+    return json.dumps(os_release_dict, indent=2)

jpcli-0.5.0/jpcli/parsers/uname_parser.py

@@ -0,0 +1,31 @@
+import json
+
+
+def parse(command_output):
+    """
+    Parses the output of the uname -a command into a dictionary.
+
+    Args:
+    command_output (str): The string output from the uname -a command.
+
+    Returns:
+    str: A JSON-formatted string with system information.
+    """
+    uname_info = {}
+    parts = command_output.split()
+
+    if len(parts) >= 6:
+        uname_info['system'] = parts[0]  # Kernel name
+        uname_info['node'] = parts[1]    # Network node hostname
+        uname_info['kernel'] = parts[2]  # Kernel release
+        uname_info['kernel_version'] = parts[3]  # Kernel version
+        uname_info['architecture'] = parts[4]  # Machine hardware name
+        uname_info['processor'] = parts[5]  # Processor type
+
+        # Additional fields if available
+        if len(parts) > 6:
+            uname_info['platform'] = parts[6]  # Platform type (e.g., GNU/Linux)
+        if len(parts) > 7:
+            uname_info['additional_info'] = ' '.join(parts[7:])  # Any remaining info
+
+    return json.dumps(uname_info, indent=2)

{jpcli-0.3.0 → jpcli-0.5.0/jpcli.egg-info}/PKG-INFO

@@ -1,10 +1,12 @@
 Metadata-Version: 2.1
 Name: jpcli
-Version: 0.3.0
+Version: 0.5.0
 Summary: A library to convert Linux command output to JSON
 Home-page: https://github.com/JaimeAdanCuevas/jpcli
 Author: Jaime Cuevas
 Author-email: adancuevas@outlook.com
+License: UNKNOWN
+Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
@@ -21,3 +23,5 @@ jpcli is a library that converts the output of various Linux commands to JSON fo
 ```sh
 pip install jpcli
 
+
+

{jpcli-0.3.0 → jpcli-0.5.0}/jpcli.egg-info/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 jpcli = jpcli.main:main
+

{jpcli-0.3.0 → jpcli-0.5.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name="jpcli",
-    version="0.3.0",
+    version="0.5.0",
     author="Jaime Cuevas",
     author_email="adancuevas@outlook.com",
     description="A library to convert Linux command output to JSON",

jpcli-0.3.0/jpcli/parsers/cmdline_parser.py

@@ -1,12 +0,0 @@
-def parse(cmdline_output):
-    """
-    Parse the contents of /proc/cmdline.
-    """
-    cmdline_dict = {}
-    for item in cmdline_output.strip().split():
-        if '=' in item:
-            key, value = item.split('=', 1)
-            cmdline_dict[key] = value
-        else:
-            cmdline_dict[item] = None
-    return cmdline_dict

jpcli-0.3.0/jpcli/parsers/cpuinfo_parser.py

@@ -1,33 +0,0 @@
-# cpuinfo_parser.py
-
-def parse(command_output):
-    """
-    Parses the output of the 'cat /proc/cpuinfo' command into a list of dictionaries,
-    where each dictionary contains information about one processor core.
-
-    Args:
-    command_output (str): The string output from the 'cat /proc/cpuinfo' command.
-
-    Returns:
-    list: A list of dictionaries, each representing a CPU core's information.
-    """
-    processors = []
-    current_processor = {}
-    lines = command_output.splitlines()
-    for line in lines:
-        line = line.strip()  # Remove leading and trailing whitespace
-        if line:
-            key_value_pair = line.split(':', 1)  # Split only on the first colon
-            if len(key_value_pair) == 2:
-                key, value = key_value_pair
-                key = key.strip()
-                value = value.strip()
-                current_processor[key] = value
-        else:
-            # Handle new processor block (empty line)
-            if current_processor:
-                processors.append(current_processor)
-                current_processor = {}
-    if current_processor:
-        processors.append(current_processor)
-    return processors

jpcli-0.3.0/jpcli/parsers/dmesg_parser.py

@@ -1,12 +0,0 @@
-def parse(dmesg_output):
-    """
-    Parse the contents of dmesg output.
-    """
-    try:
-        dmesg_lines = dmesg_output.strip().split('\n')
-        dmesg_list = []
-        for line in dmesg_lines:
-            dmesg_list.append(line)
-        return dmesg_list
-    except Exception as e:
-        return {"error": str(e), "message": "Failed to parse dmesg output"}

jpcli-0.3.0/jpcli/parsers/free_parser.py

@@ -1,22 +0,0 @@
-import json
-
-
-def parse(command_output):
-    lines = command_output.strip().split('\n')
-    headers = lines[0].split()
-    memory_data = []
-
-    for line in lines[1:]:
-        values = line.split()
-        # Ensure that the length of headers and values are the same
-        if len(values) == len(headers):
-            entry = {headers[i]: values[i] for i in range(len(headers))}
-        else:
-            # Handle cases where the line might not match header length
-            entry = {}
-            for i in range(len(values)):
-                key = headers[i] if i < len(headers) else f'unknown_{i}'
-                entry[key] = values[i]
-        memory_data.append(entry)
-
-    return json.dumps(memory_data, indent=2)

jpcli-0.3.0/jpcli/parsers/journalctl_parser.py

@@ -1,12 +0,0 @@
-def parse(journalctl_output):
-    """
-    Parse the contents of journalctl output.
-    """
-    try:
-        journalctl_lines = journalctl_output.strip().split('\n')
-        journalctl_list = []
-        for line in journalctl_lines:
-            journalctl_list.append(line)
-        return journalctl_list
-    except Exception as e:
-        return {"error": str(e), "message": "Failed to parse journalctl output"}

jpcli-0.3.0/jpcli/parsers/lsmem_parser.py

@@ -1,23 +0,0 @@
-def parse(command_output):
-    lines = command_output.splitlines()
-    data = []
-    headers = []
-
-    # Extract headers from the first line
-    if lines:
-        headers = [header.strip() for header in lines[0].split() if header.strip()]
-        lines = lines[1:]
-
-    for line in lines:
-        if not line.strip():  # Skip empty lines
-            continue
-
-        values = [value.strip() for value in line.split() if value.strip()]
-        if len(values) != len(headers):
-            # For handling lines with different formats (like summary lines)
-            data.append({headers[0]: " ".join(values)})
-        else:
-            entry = {headers[i]: values[i] for i in range(len(headers))}
-            data.append(entry)
-
-    return data

jpcli-0.3.0/jpcli/parsers/uname_parser.py

@@ -1,8 +0,0 @@
-# jpcli/parsers/uname_parser.py
-def parse(uname_output):
-    """
-    Parse the output of the `uname` command.
-    """
-    uname_info = uname_output.strip().split()
-    keys = ['sysname', 'nodename', 'release', 'version', 'machine', 'processor', 'hardware_platform', 'os']
-    return dict(zip(keys, uname_info))