jpcli 0.1.3__tar.gz → 0.3.0__tar.gz

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

@@ -1,12 +1,10 @@
 Metadata-Version: 2.1
 Name: jpcli
-Version: 0.1.3
+Version: 0.3.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
@@ -23,5 +21,3 @@ jpcli is a library that converts the output of various Linux commands to JSON fo
 ```sh
 pip install jpcli
 
-
-

jpcli-0.3.0/jpcli/main.py

@@ -0,0 +1,75 @@
+
+import argparse
+import subprocess
+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,
+        '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="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()
+
+    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(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-0.3.0/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-0.3.0/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-0.3.0/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-0.3.0/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-0.3.0/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-0.3.0/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-0.3.0/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-0.3.0/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-0.1.3 → jpcli-0.3.0}/jpcli/parsers/lsmem_parser.py

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

jpcli-0.3.0/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-0.3.0/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-0.3.0/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 → jpcli-0.3.0/jpcli.egg-info}/PKG-INFO

@@ -1,12 +1,10 @@
 Metadata-Version: 2.1
 Name: jpcli
-Version: 0.1.3
+Version: 0.3.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
@@ -23,5 +21,3 @@ jpcli is a library that converts the output of various Linux commands to JSON fo
 ```sh
 pip install jpcli
 
-
-

jpcli-0.3.0/jpcli.egg-info/SOURCES.txt

@@ -0,0 +1,28 @@
+LICENCE
+MANIFEST.in
+README.md
+setup.py
+jpcli/__init__.py
+jpcli/main.py
+jpcli.egg-info/PKG-INFO
+jpcli.egg-info/SOURCES.txt
+jpcli.egg-info/dependency_links.txt
+jpcli.egg-info/entry_points.txt
+jpcli.egg-info/top_level.txt
+jpcli/parsers/__init__.py
+jpcli/parsers/cmdline_parser.py
+jpcli/parsers/cpuinfo_parser.py
+jpcli/parsers/df_parser.py
+jpcli/parsers/dmesg_parser.py
+jpcli/parsers/free_parser.py
+jpcli/parsers/ifconfig_parser.py
+jpcli/parsers/journalctl_parser.py
+jpcli/parsers/lscpu_parser.py
+jpcli/parsers/lshw_parser.py
+jpcli/parsers/lsmem_parser.py
+jpcli/parsers/mcelog_parser.py
+jpcli/parsers/os_release_parser.py
+jpcli/parsers/uname_parser.py
+tests/__init__.py
+tests/test_lsmem_parser.py
+tests/test_other_command_parser.py

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

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

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

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

{jpcli-0.1.3 → jpcli-0.3.0}/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-0.1.3/jpcli/main.py

@@ -1,45 +0,0 @@
-
-import argparse
-import subprocess
-from .parsers import lsmem_parser, free_parser, other_command_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
-    }
-    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')
-
-    args = parser.parse_args()
-    result = jpcli(args.command, args.parser_name)
-    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
-    return parse_command_output(command_output, parser_name)
-
-if __name__ == '__main__':
-    main()
-

jpcli-0.1.3/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/jpcli.egg-info/SOURCES.txt

@@ -1,18 +0,0 @@
-LICENCE
-MANIFEST.in
-README.md
-setup.py
-jpcli/__init__.py
-jpcli/main.py
-jpcli.egg-info/PKG-INFO
-jpcli.egg-info/SOURCES.txt
-jpcli.egg-info/dependency_links.txt
-jpcli.egg-info/entry_points.txt
-jpcli.egg-info/top_level.txt
-jpcli/parsers/__init__.py
-jpcli/parsers/free_parser.py
-jpcli/parsers/lsmem_parser.py
-jpcli/parsers/other_command_parser.py
-tests/__init__.py
-tests/test_lsmem_parser.py
-tests/test_other_command_parser.py

{jpcli-0.1.3 → jpcli-0.3.0}/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)
-