hereisyou 0.1.2__py3-none-any.whl

hereisyou/You/__init__.py

@@ -0,0 +1,9 @@
+from .introspection import You
+"""
+BInspected: A recursive Python object introspection engine.
+This module provides the BInspected class, which classifies Python
+objects, extracts metadata, groups children, and recursively builds
+a structured introspection dictionary.
+"""
+
+__all__ = ['You']

hereisyou/You/classifier.py

@@ -0,0 +1,138 @@
+# This file is part of HereIsYou
+# Copyright (C) 2026 Donald Raymond Reilly Jr.
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from types import (
+    ModuleType,
+    MethodType,
+    FunctionType,
+    BuiltinFunctionType,
+    BuiltinMethodType,
+)
+
+
+class Classifier:
+    # TODO: For now i'm going to keep this too expanded class. Just incase I want to expand on this later. Gonna seem like a waste for now.
+    # TODO: Need to figure out the whole instance thing and how to actaully handle the __dict__ of some objects. it's a problem that i just passed over for now.
+    def __init__(self):
+        pass
+
+    def __call__(self, object_to_classify) -> str:
+        """
+        Calls the classifier on an object and returns a string representation of the classification.
+
+        params:
+            object_to_classify: Object to be classified.
+        return:
+            string representation of the classification of the provided object.
+        """
+
+        return self.classify_initial_object(object_to_classify)
+
+    def classify_initial_object(self, object_to_classify) -> str:
+        """
+        Classifies objects and all of it's attributes and returns a dictionary representation of the classification.
+
+        params:
+            object_to_classify: Object to be classified.
+        return:
+            dictionary representation of the classification of the provided object and all of it's attributes.
+        """
+
+        if isinstance(object_to_classify, ModuleType):
+            return "module"
+        if isinstance(object_to_classify, type):
+            return "class"
+        if isinstance(object_to_classify, MethodType):
+            return "method"
+        if isinstance(object_to_classify, FunctionType):
+            return "function"
+        if isinstance(object_to_classify, property):
+            return "property"
+        if object_to_classify.__class__.__module__ == "builtins":
+            return "built-in"
+        return "instance"
+
+    def classify_module(self, module_to_classify: ModuleType) -> str:
+        """
+        Classifies modules and all of it's attributes and returns a dictionary representation of the classification.
+
+        params:
+            module_to_classify: Module to be classified.
+        return:
+            dictionary representation of the classification of the provided module and all of it's attributes.
+        """
+
+        return "module"
+
+    def classify_instance_of_user_defined_class(self, instance_to_classify: object) -> str:
+        """
+        Classifies instances of user-defined classes and all of it's attributes and returns a dictionary representation of the classification.
+
+        params:
+            instance_to_classify: Instance of a user-defined class to be classified.
+        return:
+            dictionary representation of the classification of the provided instance of a user-defined class and all of it's attributes.
+        """
+
+        return "instance of user-defined class"
+
+    def classify_class(self, class_to_classify: type) -> str:
+        """
+        Classifies classes and all of it's attributes and returns a dictionary representation of the classification.
+
+        params:
+            class_to_classify: Class to be classified.
+        return:
+            dictionary representation of the classification of the provided class and all of it's attributes.
+        """
+
+        return "class"
+
+    def classify_method(self, method_to_classify: MethodType) -> str:
+        """
+        Classifies methods and all of it's attributes and returns a dictionary representation of the classification.
+
+        params:
+            method_to_classify: Method to be classified.
+        return:
+            dictionary representation of the classification of the provided method and all of it's attributes.
+        """
+
+        return "method"
+
+    def classify_function(self, function_to_classify: FunctionType) -> str:
+        """
+        Classifies functions and all of it's attributes and returns a dictionary representation of the classification.
+
+        params:
+            function_to_classify: Function to be classified.
+        return:
+            dictionary representation of the classification of the provided function and all of it's attributes.
+        """
+
+        return "function"
+
+    def classify_property(self, property_to_classify: property) -> str:
+        """
+        Classifies properties and all of it's attributes and returns a dictionary representation of the classification.
+
+        params:
+            property_to_classify: Property to be classified.
+        return:
+            dictionary representation of the classification of the provided property and all of it's attributes.
+        """
+
+        return "property"

hereisyou/You/introspection.py

@@ -0,0 +1,307 @@
+# This file is part of HereIsYou
+# Copyright (C) 2026 Donald Raymond Reilly Jr.
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from .classifier import Classifier
+from  .parser import Parser
+# BUG Empty fields shouldn't show in json.
+
+# WORK CLI needs to be done. Should be able to run and inspect files seperately.
+# DEBT Finish parsing args.
+
+# ROADMAP Raw file inspection for self testing and testing of classes. 
+class You:
+    """
+    You: A look into your modules, class, method, or function for debugging
+    purposes.
+
+    This modusle provides the BInspected class, which classifies Python
+    objects, extracts metadata, groups children, and recursively builds
+    a structured introspection dictionary.
+    """
+
+    def __init__(self):
+        """
+        Initializes the BInspected class.
+        """
+
+        self.dispatcher = {
+            "module": self._inspect_module,
+            "class": self._inspect_class,
+            "method": self._inspect_method,
+            "instance": self._inspect_class_instance,
+            "property": self._inspect_property,
+            "built-in": self._inspect_built_in,
+            "function": self._inspect_function,
+        }
+        self.classifier = Classifier()
+        self.parser = Parser()
+
+    def __call__(self, object_to_inspect) -> dict:
+        """
+        Classify an object and return it's introspection dictionary.
+
+        Params:
+            object_to_inspect: Object to be inspected.
+        Returns:
+            An introspection dictionary.
+        """
+
+        return self._build_inspection(object_to_inspect)
+
+    def _build_inspection(self, object_to_inspect) -> dict:
+        """
+        Complete object inspection and formation of the objects underlying 
+        structure
+
+        Params:
+            object_to_inspect: Object to inspect
+        Returns:
+            An introspection dictionary
+        """
+
+        object_type = self.classifier(object_to_inspect)
+        parsed_object = self.dispatcher[object_type](object_to_inspect, 
+                                                     object_type)
+
+        return parsed_object
+
+    def _group_children(self, dict_to_group) -> dict:
+        """
+        Sort an objects __dict__
+
+        Params:
+            dict_to_group: __dict__ of the object that needs sorting
+        Returns:
+            A dictionary of the sorted objects. Example structure:
+            grouped_dict ={
+                "module": {},
+                "class": {},
+                "method": {},
+                "function": {},
+                "property": {},
+                "instance": {}
+            }
+        """
+
+        # System specific children who don't need to be inspected... yet..
+        skip_children = [
+            "__loader__",
+            "__spec__ ",
+            "__package__",
+            "__builtins__",
+            "__cached__",
+            "__file__",
+        ]
+        # The layout of the returned dictionary needs to be removed eventually 
+        # and be formed at creation
+        grouped_dict = {
+            "module": {},
+            "class": {},
+            "method": {},
+            "function": {},
+            "property": {},
+            "instance": {},
+        }
+        # Loop for sorting the __dict__
+        for key, value in dict_to_group.items():
+            if key in skip_children:  # Skips the system entries.
+                continue
+            # Classifies each child object
+            object_type = self.classifier(value)
+            if object_type in grouped_dict:
+                # Sorts each object in correct dictionary entry.
+                grouped_dict[object_type][key] = value
+        return grouped_dict
+
+    def _get_children(self, object_to_get_children) -> dict:
+        """
+        Gets the children objects and recursively sorts and produces 
+        dictionaries.
+
+        Params:
+            object_to_get_children: The object whose children need sorting and 
+            parsing.
+        Returns:
+            The parsed dictionary of each child object.
+        """
+
+        # TODO: This needs a little rework. It's ok for now, but it's unclear 
+        # exactly what it's doing and that could be fixed.
+        # TODO: Maybe just a renaming so it's function is clear. This is the 
+        # problem with recursion, it confuses shit.
+        # Get the sorted dictionary of the children objects
+        children_dict = self._group_children(object_to_get_children.__dict__)
+        # Loop through the sorted dictionary and recursively sort and inspect 
+        # the children.
+        for children_objects in children_dict.values():
+            for object_name, object_ref in children_objects.items():
+                # call back to inspected to start the loop over again.
+                children_objects[object_name] = self(object_ref)
+        return children_dict
+
+    def _inspect_module(self, module_to_inspect, object_type) -> dict:
+        """
+        Inspect a modules underlying data structure and provide an 
+        introspection dictionary.
+
+        Params:
+            module_to_inspect: Module to inspect
+        Returns:
+            An introspection dictionary
+        """
+
+        # Gets meta data and build dictionary.
+        module_dict = self.parser(module_to_inspect, object_type)
+        # Starts recursion.
+        module_dict["children"] = self._get_children(module_to_inspect)
+        return module_dict
+
+    def _inspect_class(self, class_to_inspect, object_type) -> dict:
+        """
+        Inspect a class' underlying data structure and provide an introspection 
+        dictionary.
+
+        Params:
+            class_to_inspect: Class to inspect
+        Returns:
+            An introspection dictionary
+        """
+
+        # Creates the dictionary representation of the provided class.
+        class_dict = self.parser(class_to_inspect, object_type)
+        # Pulls out the children of the provided class and sorts them 
+        # accordingly.
+        class_dict["children"] = self._get_children(class_to_inspect)
+        return class_dict
+
+    def _inspect_class_instance(self, instance_to_inspect, object_type) -> dict:
+        """
+        Inspect an instances underlying data structure and provide an 
+        introspection dictionary.
+
+        Params:
+            instance_to_inspect: instance to inspect
+        Returns:
+            An introspection dictionary
+        """
+
+        # Creates the dictionary representation of the provided instance of a 
+        # class.
+        instance_dict = self.parser(instance_to_inspect, object_type)
+        # Sends the underlying class by through self for classification and 
+        # parsing.
+        class_dict = self(instance_to_inspect.__class__)
+        # Merges the two dictionaries.
+        instance_dict = instance_dict | class_dict
+        return instance_dict
+
+    def _inspect_method(self, method_to_inspect, object_type) -> dict:
+        """
+        Inspect a methods underlying data structure and provide an 
+        introspection dictionary.
+
+        Params:
+            method_to_inspect: Method to inspect
+        Returns:
+            An introspection dictionary
+        """
+
+        # Creates the dicitonary representation of the provided method.
+        method_dict = self.parser(method_to_inspect, object_type)
+        # Sends the underlying function to the correct inspecetion method.
+        function_dict = self(method_to_inspect.__func__)
+        # Merges the two introspection dictionaries.
+        method_dict |= function_dict
+        return method_dict
+
+    def _inspect_function(self, function_to_inspect, object_type) -> dict:
+        """
+        Inspect a functions underlying data structure and provide an 
+        introspection dictionary.
+
+        Params:
+            function_to_inspect: Function to inspect
+        Returns:
+            An introspection dictionary
+        """
+
+        # Create the dictionary representation of the provided function.
+        function_dict = self.parser(function_to_inspect, object_type)
+        # Sends the functions variables for parsing.
+        function_dict["variables"] = self.parser._parse_variables(
+            function_to_inspect)
+        return function_dict
+
+    def _inspect_property(self, property_to_inspect, object_type) -> dict:
+        """
+        Inspect a property's underlying data structure and provide an 
+        introspection dictionary.
+
+        Params:
+            property_to_inspect: Property to inspect
+        Returns:
+            An introspection dictionary
+        """
+
+        # Creates the dictionary representation of the provided property.
+        property_dict = self.parser(property_to_inspect, object_type)
+        # Sends the underlying functions to the correct inspection method.
+        property_dict["getter"] = (self(property_to_inspect.fget) if 
+                                   property_to_inspect.fget else None)
+        # Sends the underlying functions to the correct inspection method.
+        property_dict["setter"] = (self(property_to_inspect.fset) if property_to_inspect.fset else None)
+        # Sends the underlying functions to the correct inspection method.
+        property_dict["deleter"] = (self(property_to_inspect.fdel) if property_to_inspect.fdel else None)
+        return property_dict
+
+    def _inspect_built_in(self, instance_to_inspect) -> dict:
+        """
+        Inspect the built_in underlying data structure and provide an introspection dictionary.
+
+        Params:
+            built_in_to_inspect: built_in to inspect
+        Returns:
+            An introspection dictionary
+        """
+
+        # TODO: Possible feature, and flag. Not sure if built-ins should even be tested. Would make some very heavy duty outputs.
+        return {"Not Implemented": "_inspect_built_in"}
+
+    def _inspect_arguments(self, arguments_to_inspect) -> dict:
+        """
+        Inspect an arguments underlying data structure and provide an introspection dictionary.
+
+        Params:
+            argument_to_inspect: Argument to inspect
+        Returns:
+            An introspection dictionary
+        """
+
+        # TODO: Decide if this needs to exist or if the code should exist in parser.
+        return {"type argument": "argument type"}
+
+    def _inspect_variables(self, variables_to_inspect, object_type) -> dict:
+        """
+        Inspect a variables underlying data structure and provide an introspection dictionary.
+
+        Params:
+            variable_to_inspect: Variable to inspect
+        Returns:
+            An introspection dictionary
+        """
+
+        # TODO: Decide if this needs to exist or if the code should exist in parser.
+        return {"type variable": "variable type"}

hereisyou/You/parser.py

@@ -0,0 +1,145 @@
+# This file is part of HereIsYou
+# Copyright (C) 2026 Donald Raymond Reilly Jr.
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+class Parser:
+    """
+    Parser: Extracts meta data from python objects.
+
+    This class parses python objects to provide clean and readable meta data.
+    """
+
+    def __init__(self) -> None:
+        """
+        Initializes the Parser class.
+        """
+
+        # The method dispatcher, currently not in use, would like to add for easy extension.
+        self.dispatcher = {
+            # "module": self.parse_module,
+            # "class": self.parse_class,
+            # "method": self.parse_method,
+            "instance": self._parse_class_instance
+            # "function": self.parse_function,
+            # "property": self.parse_property
+        }
+
+    def __call__(self, object_to_parse, object_type=None) -> dict:
+        """
+        Parse an object of a given type and return a dictionary representation.
+
+        Params:
+            object_to_parse: The object to be parsed.
+            object_type: The type of the object to be parsed.
+        Returns:
+            A dictionary representation of the parsed object.
+        """
+
+        return self._parse_object(
+            object_to_parse=object_to_parse, object_type=object_type
+        )
+
+    def _parse_object(self, object_to_parse, object_type=None) -> dict:
+        """Parse an object of a given type and return a dictionary representation
+
+        Params:
+            object_to_parse: The object to be parsed.
+            object_type: The type of the object to be parsed.
+        Returns:
+            A dicitonary representation of the parsed object.
+
+        """
+
+        meta_data_dict = self._extract_meta_data(object_to_parse)
+        if object_type in self.dispatcher:
+            meta_data_dict |= self.dispatcher[object_type](object_to_parse)
+        return meta_data_dict
+
+    def _extract_meta_data(self, object_to_parse) -> dict:
+        """
+        Parse an object, extract meta-data and format it into a dictionary.
+
+        Params:
+            object_to_parse: The object to be parsed.
+            object_type: The Name of the object to be parsed.
+        Returns:
+            A dictionary representation of the meta data.
+        """
+
+        # Calls to meta data to be extracted.
+        meta_data_map = {
+            "name": lambda: object_to_parse.__name__,  # Object name
+            "qualified name": lambda: object_to_parse.__qualname__,  # Qualified object name
+            "module name": lambda: object_to_parse.__module__,  # Objects module name
+            "bases": lambda: object_to_parse.__bases__,  # Base class names
+            "doc string": lambda: object_to_parse.__doc__,  # Doc String
+            "type hints": lambda: object_to_parse.__annotations__,  #   type hinting of variables
+        }
+        meta_data_dict = {}  # Initializng the meta data dictionary.
+        for (meta_data) in (meta_data_map):  # For loop that cycles the meta data map and updates the meta_data dict if an expection isn't encountred.
+            try:
+                meta_data_dict[meta_data] = meta_data_map[meta_data]()
+            except:
+                continue
+        return meta_data_dict
+
+    def _parse_class_instance(self, instance_to_parse) -> dict:
+        """
+        Parse an instance of a class and return a dictionary representation of it.
+
+        Params:
+            instance_to_parse: The instance of a class to be parsed.
+        Returns:
+            A dictionary representation of the parsed instance of a class.
+        """
+
+        # Pulls the instance variables.
+        instance_dict = {"Instance Variables": instance_to_parse.__dict__}
+        return instance_dict
+
+    def _parse_variables(self, function_to_parse) -> dict[str,  ]:
+        """
+        Parse the variables of a function.
+
+        Params:
+            function_to_parse: The functions whose variables need parsing.
+        Returns:
+            A dictionary representation of the parsed variables.
+        """
+
+        allvars = function_to_parse.__code__.co_varnames
+        argsn = function_to_parse.__code__.co_argcount
+        anns = function_to_parse.__annotations__ or ()
+        defs = function_to_parse.__defaults__ or ()
+        ldegs = len(defs)
+        localvar = allvars[argsn:]
+        args = allvars[:argsn]
+
+        templst = [None] * (argsn-ldegs)
+        templst += defs
+
+        variables_defaults = list(zip(args,templst))
+        dict_laid_out =[]
+
+        for item in variables_defaults:
+                tempd = {
+                    "name": item[0],
+                    "default": item[1],
+                    "type":anns[item[0]] if item[0] in anns else None
+                }
+                dict_laid_out.append(tempd)
+
+        return dict_laid_out
+

hereisyou/__init__.py

@@ -0,0 +1,3 @@
+from hereisyou.You import You
+
+__all__ = ['You']