jpcli 0.1.3__py3-none-any.whl → 0.2.0__py3-none-any.whl

jpcli/main.py

@@ -1,45 +1,75 @@
 
 import argparse
 import subprocess
-from .parsers import lsmem_parser, free_parser, other_command_parser
+import sys
+from .parsers import lsmem_parser, free_parser, df_parser, lshw_parser, lscpu_parser, cpuinfo_parser, uname_parser, ifconfig_parser, cmdline_parser, os_release_parser, dmesg_parser, journalctl_parser, mcelog_parser
+
 
 def run_command(command):
+
     result = subprocess.run(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     if result.returncode != 0:
         raise RuntimeError(f"Command '{command}' failed with error: {result.stderr.decode()}")
     return result.stdout.decode()
 
+
 def parse_command_output(command_output, parser_name):
+
     parsers = {
         'lsmem': lsmem_parser.parse,
         'free': free_parser.parse,
-        # Add other parsers here
+        'df': df_parser.parse,
+        'lshw': lshw_parser.parse,
+        'lscpu': lscpu_parser.parse,
+        'cpuinfo': cpuinfo_parser.parse,
+        'uname': uname_parser.parse,
+        'ifconfig': ifconfig_parser.parse,
+        'cmdline': cmdline_parser.parse,
+        'os-release': os_release_parser.parse,
+        'dmesg': dmesg_parser.parse,
+        'journalctl', journalctl_parser.parse,
+        'mcelog', mcelog_parser.parse,
     }
     if parser_name in parsers:
         return parsers[parser_name](command_output)
     else:
         raise ValueError(f"No parser found for {parser_name}")
 
+
 def main():
-    parser = argparse.ArgumentParser(description='JP - JSON Parser for Linux commands')
-    parser.add_argument('command', type=str, help='The Linux command to run')
-    parser.add_argument('parser_name', type=str, nargs='?', default=None, help='The name of the parser to use')
 
+    parser = argparse.ArgumentParser(description="Parse Linux command outputs into JSON")
+    parser.add_argument('parser_name', help='The name of the parser to use')
+    parser.add_argument('command', nargs='?', default=None, help='The Linux command to run (optional, reads from stdin if omitted)')
     args = parser.parse_args()
-    result = jpcli(args.command, args.parser_name)
+
+    if not args.command and not args.parser_name:
+        print("Error: Parser is required when reading from stdin or command for stdout", file=sys.stderr)
+        parser.print_help()
+        sys.exit(1)
+
+    if args.command is None:
+        args.command = args.parser_name
+
+    result = jpcli(args.parser_name, args.command)
     print(result)
 
-def jpcli(command, parser_name=None):
-    result = subprocess.run(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-    if result.returncode != 0:
-        print(f"Error: {result.stderr}", file=sys.stderr)
-        sys.exit(result.returncode)
 
-    command_output = result.stdout
-    if parser_name is None:
-        parser_name = command.split()[0]  # Use the first word of the command as the parser name
+def jpcli(parser_name, command):
+
+    if sys.stdin.isatty():
+        # Not receiving piped data, execute the command
+        result = subprocess.run(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        if result.returncode != 0:
+            print(f"Error: {result.stderr}", file=sys.stderr)
+            sys.exit(result.returncode)
+        command_output = result.stdout
+    else:
+        command_output = sys.stdin.read()
+        parser_name = command  # Use the command as the parser name
+
     return parse_command_output(command_output, parser_name)
 
+
 if __name__ == '__main__':
     main()
-

jpcli/parsers/cmdline_parser.py

@@ -0,0 +1,12 @@
+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/parsers/cpuinfo_parser.py

@@ -0,0 +1,33 @@
+# 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/parsers/df_parser.py

@@ -0,0 +1,16 @@
+def parse(command_output):
+    lines = command_output.splitlines()
+    data = []
+    headers = [header.strip() for header in lines[0].split()]
+
+    for line in lines[1:]:
+        if not line.strip():
+            continue
+        values = line.split()
+        if len(values) < len(headers):
+            # Handle lines with missing values
+            values.extend([''] * (len(headers) - len(values)))
+        entry = {headers[i]: values[i] for i in range(len(headers))}
+        data.append(entry)
+
+    return data

jpcli/parsers/dmesg_parser.py

@@ -0,0 +1,12 @@
+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/parsers/free_parser.py

@@ -1,5 +1,6 @@
 import json
 
+
 def parse(command_output):
     lines = command_output.strip().split('\n')
     headers = lines[0].split()
@@ -19,4 +20,3 @@ def parse(command_output):
         memory_data.append(entry)
 
     return json.dumps(memory_data, indent=2)
-

jpcli/parsers/ifconfig_parser.py

@@ -0,0 +1,40 @@
+import re
+
+
+def parse(ifconfig_output):
+    """
+    Parse the output of the `ifconfig` command.
+    """
+    interfaces = {}
+    current_interface = None
+
+    for line in ifconfig_output.splitlines():
+        if not line.startswith(' '):
+            if current_interface:
+                interfaces[current_interface['name']] = current_interface
+            match = re.match(r'(\S+): flags=.*', line)
+            if match:
+                current_interface = {
+                    'name': match.group(1),
+                    'inet': [],
+                    'inet6': [],
+                    'ether': None
+                }
+        elif current_interface:
+            if 'inet ' in line:
+                match = re.search(r'inet (\S+)', line)
+                if match:
+                    current_interface['inet'].append(match.group(1))
+            elif 'inet6 ' in line:
+                match = re.search(r'inet6 (\S+)', line)
+                if match:
+                    current_interface['inet6'].append(match.group(1))
+            elif 'ether ' in line:
+                match = re.search(r'ether (\S+)', line)
+                if match:
+                    current_interface['ether'] = match.group(1)
+
+    if current_interface:
+        interfaces[current_interface['name']] = current_interface
+
+    return interfaces

jpcli/parsers/journalctl_parser.py

@@ -0,0 +1,12 @@
+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/parsers/lscpu_parser.py

@@ -0,0 +1,33 @@
+def parse(command_output):
+    """
+    Parses the output of the lscpu command into a dictionary.
+
+    Args:
+    command_output (str): The string output from the lscpu command.
+
+    Returns:
+    dict: A dictionary with CPU properties as keys and their corresponding values.
+    """
+    cpu_info = {}
+    lines = command_output.splitlines()
+    for line in lines:
+        if line.strip():  # Ensure the line is not empty
+            parts = line.split(':')
+            if len(parts) == 2:
+                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)

jpcli/parsers/lshw_parser.py

@@ -0,0 +1,38 @@
+def parse(command_output):
+    def parse_section(lines, indent_level):
+        data = {}
+        current_section = {}  # Initialize as empty dictionary
+        while lines:
+            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
+            elif indent == indent_level and line.startswith('       '):
+                parts = line.strip().split(': ', 1)
+                if len(parts) == 2:
+                    current_section[parts[0]] = parts[1]  # Direct assignment
+                elif len(parts) == 1:
+                    current_section[parts[0]] = None
+            elif indent > indent_level:
+                if current_section:
+                    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))

jpcli/parsers/lsmem_parser.py

@@ -21,4 +21,3 @@ def parse(command_output):
             data.append(entry)
 
     return data
-

jpcli/parsers/mcelog_parser.py

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

jpcli/parsers/os_release_parser.py

@@ -0,0 +1,11 @@
+# jpcli/parsers/os_release_parser.py
+def parse(os_release_output):
+    """
+    Parse the contents of /etc/os-release.
+    """
+    os_release_dict = {}
+    for line in os_release_output.strip().split('\n'):
+        if '=' in line:
+            key, value = line.split('=', 1)
+            os_release_dict[key] = value.strip('"')
+    return os_release_dict

jpcli/parsers/uname_parser.py

@@ -0,0 +1,8 @@
+# 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))

{jpcli-0.1.3.dist-info → jpcli-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jpcli
-Version: 0.1.3
+Version: 0.2.0
 Summary: A library to convert Linux command output to JSON
 Home-page: https://github.com/JaimeAdanCuevas/jpcli
 Author: Jaime Cuevas

jpcli-0.2.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+jpcli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jpcli/main.py,sha256=TagNzxSxhSV-ttrAomkLIBnHyJRlw5twsKLY0M-3_i0,2610
+jpcli/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jpcli/parsers/cmdline_parser.py,sha256=HKiI_iGS1Iy6JKJFLUFPsfxyqYo57rPonKfvFfmQTqg,336
+jpcli/parsers/cpuinfo_parser.py,sha256=weYBoGBL8e82kkRAtAJvmWOMx-R3L72gRNKmgAg3DWQ,1177
+jpcli/parsers/df_parser.py,sha256=NC377ld_uUo9MxkGrxYjCAyFq2BdAQL4pgJtz4u3kL8,513
+jpcli/parsers/dmesg_parser.py,sha256=76AkYlcVvo3_5qzuPreTQaelPsExaEct1NDfniiySM0,367
+jpcli/parsers/free_parser.py,sha256=GJuJKCT4cIN4O5D-rHjalx-6FzDT6-lpUurmh9PnUKE,721
+jpcli/parsers/ifconfig_parser.py,sha256=KgtXPGG6QKKFID4YjHwJbL-jbTVoFB8SBjIyop2ICL4,1319
+jpcli/parsers/journalctl_parser.py,sha256=1pGAlrM7oe2vOCnspjdHk_RqDUDxlL2sBpfJJXlWxDU,412
+jpcli/parsers/lscpu_parser.py,sha256=8kAqrFLyVR-vEW6ODlx1fwF1HRNeCTt2CHQ2ZI1bQWg,881
+jpcli/parsers/lshw_parser.py,sha256=QUHE3ya64aaH9Md0VqMK-YQo457W8V8RgClxS41zRx8,1558
+jpcli/parsers/lsmem_parser.py,sha256=vdIyK0xsbrfkqxWOx6jLz-2gsrH5Ii-8mwx-PkL_fXI,744
+jpcli/parsers/mcelog_parser.py,sha256=z62xUwSy_DU-KlPh6d-Xmrz2qMQYVG8JDs7aZE7i7Gk,376
+jpcli/parsers/os_release_parser.py,sha256=5x_tjsG2Jvw1Lx-hVHHbuAMc3d8POPXDQ7Kt9Ux6GG4,353
+jpcli/parsers/uname_parser.py,sha256=dSPRtiSVxeBt7fdQCjU_zVvf63eU-lwxoOPMlahWkfQ,311
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_lsmem_parser.py,sha256=mRlHTmU2ZmcxPGgcqAv_LNGs56yrwDBiw2-aHKrpuEo,793
+tests/test_other_command_parser.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jpcli-0.2.0.dist-info/LICENCE,sha256=-unHZSaIlcrVEVD56Ss5dlOvdgK682a2xitz35UlKt4,1069
+jpcli-0.2.0.dist-info/METADATA,sha256=WFMCyc8oddjmsVZMLpkuF4n4-d2orJkpl9k73V46j1M,625
+jpcli-0.2.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+jpcli-0.2.0.dist-info/entry_points.txt,sha256=6wCYs9scOVGFsZE-b2r2geNzy4uST0GgWyHmveiPSxE,43
+jpcli-0.2.0.dist-info/top_level.txt,sha256=djdbp8mEzCmAEbrMOVEHNW4LIabBwnpLURp2dX_ZQbA,12
+jpcli-0.2.0.dist-info/RECORD,,

tests/test_lsmem_parser.py

@@ -1,6 +1,7 @@
 import unittest
 from jpcli.parsers import lsmem_parser
 
+
 class TestLsmemParser(unittest.TestCase):
 
     def test_parse(self):
@@ -15,5 +16,6 @@ RANGE                                 SIZE  STATE REMOVABLE  BLOCK
         ]
         self.assertEqual(lsmem_parser.parse(command_output), expected_output)
 
+
 if __name__ == '__main__':
     unittest.main()

jpcli/parsers/other_command_parser.py

@@ -1,5 +0,0 @@
-def parse(command_output):
-    # Implement parsing logic for the other command
-    data = {}
-    # Parsing logic here
-    return data

jpcli-0.1.3.dist-info/RECORD

@@ -1,15 +0,0 @@
-jpcli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jpcli/main.py,sha256=yqnw53CJ6cBFtV6X1ujy3sfKGu9I3Tp9Rrrm1gcOauU,1653
-jpcli/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jpcli/parsers/free_parser.py,sha256=XymIi1eafmIElMMVxS3DmlZ-oC4dcYvKmNWDm5tCEEs,721
-jpcli/parsers/lsmem_parser.py,sha256=EFGZISeaH9esGOnj_lYX0_biZjKnWo23dtDY9-LZ42s,745
-jpcli/parsers/other_command_parser.py,sha256=G2so9nFluHiyuyEDJouxuN4FHkNheyIY_laDFXxE6xM,134
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/test_lsmem_parser.py,sha256=maT0mCSFyAHCMdRMl0NEa-FUE_2-MMDoYZS5W67PYZU,791
-tests/test_other_command_parser.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jpcli-0.1.3.dist-info/LICENCE,sha256=-unHZSaIlcrVEVD56Ss5dlOvdgK682a2xitz35UlKt4,1069
-jpcli-0.1.3.dist-info/METADATA,sha256=UKRlNwr6g41gzrQT1zw2xNbiVun-CZ0NU-uoyAhu--w,625
-jpcli-0.1.3.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-jpcli-0.1.3.dist-info/entry_points.txt,sha256=6wCYs9scOVGFsZE-b2r2geNzy4uST0GgWyHmveiPSxE,43
-jpcli-0.1.3.dist-info/top_level.txt,sha256=djdbp8mEzCmAEbrMOVEHNW4LIabBwnpLURp2dX_ZQbA,12
-jpcli-0.1.3.dist-info/RECORD,,