jpcli 0.2.0__tar.gz → 0.4.0__tar.gz

{jpcli-0.2.0/jpcli.egg-info → jpcli-0.4.0}/PKG-INFO

@@ -1,27 +1,24 @@
 Metadata-Version: 2.1
 Name: jpcli
-Version: 0.2.0
+Version: 0.4.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
+Description: # jpcli
+        
+        jpcli is a library that converts the output of various Linux commands to JSON format.
+        
+        ## Installation
+        
+        ```sh
+        pip install jpcli
+        
+        
 Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
-License-File: LICENCE
-
-# jpcli
-
-jpcli is a library that converts the output of various Linux commands to JSON format.
-
-## Installation
-
-```sh
-pip install jpcli
-
-
-

{jpcli-0.2.0 → jpcli-0.4.0}/jpcli/main.py

@@ -27,8 +27,8 @@ def parse_command_output(command_output, parser_name):
         'cmdline': cmdline_parser.parse,
         'os-release': os_release_parser.parse,
         'dmesg': dmesg_parser.parse,
-        'journalctl', journalctl_parser.parse,
-        'mcelog', mcelog_parser.parse,
+        'journalctl': journalctl_parser.parse,
+        'mcelog': mcelog_parser.parse,
     }
     if parser_name in parsers:
         return parsers[parser_name](command_output)

jpcli-0.4.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.4.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.2.0 → jpcli-0.4.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.4.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.2.0 → jpcli-0.4.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.4.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.2.0 → jpcli-0.4.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.2.0 → jpcli-0.4.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.4.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.2.0 → jpcli-0.4.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.2.0 → jpcli-0.4.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.4.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.2.0 → jpcli-0.4.0/jpcli.egg-info}/PKG-INFO

@@ -1,27 +1,24 @@
 Metadata-Version: 2.1
 Name: jpcli
-Version: 0.2.0
+Version: 0.4.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
+Description: # jpcli
+        
+        jpcli is a library that converts the output of various Linux commands to JSON format.
+        
+        ## Installation
+        
+        ```sh
+        pip install jpcli
+        
+        
 Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
-License-File: LICENCE
-
-# jpcli
-
-jpcli is a library that converts the output of various Linux commands to JSON format.
-
-## Installation
-
-```sh
-pip install jpcli
-
-
-

{jpcli-0.2.0 → jpcli-0.4.0}/jpcli.egg-info/SOURCES.txt

@@ -1,4 +1,3 @@
-LICENCE
 MANIFEST.in
 README.md
 setup.py

{jpcli-0.2.0 → jpcli-0.4.0}/setup.py

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

jpcli-0.2.0/LICENCE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Jaime Cuevas
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

jpcli-0.2.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.2.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.2.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.2.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.2.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.2.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))