get-module-underlying 0.0.1__py3-none-any.whl

_exceptions.py

@@ -0,0 +1,5 @@
+# _exceptions.py
+
+class ValidNotTrueWarning(Warning):
+    """Raised when the module is not valid."""
+    pass

get_module_underlying-0.0.1.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.1
+Name: get-module-underlying
+Version: 0.0.1
+Summary: Explore Python modules deeper than dir()
+Home-page: UNKNOWN
+Author: San Zhang
+Author-email: san.zhang@example.com
+License: MIT
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: absence
+
+# get_module_underlying
+
+Explore Python modules deeper than `dir()`.
+
+## Installation
+
+```bash
+pip install get_module_underlying
+```
+
+## Usage
+
+```python
+from get_module_underlying import ModuleExplorer
+
+# Explore a module
+explorer = ModuleExplorer('sys')
+
+# Get all attributes (excluding __xxx__)
+print(explorer.get_all_attrs())
+
+# Get only public attributes
+print(explorer.get_public_attrs())
+
+# Get private attributes (single underscore)
+print(explorer.get_private_attrs())
+
+# Get dunder attributes (__xxx__)
+print(explorer.get_dunder_attrs())
+
+# Get callable methods/functions
+print(explorer.get_callable_attrs())
+
+# Get non-callable attributes (variables, constants)
+print(explorer.get_non_callable_attrs())
+
+# Get attributes with their values
+print(explorer.get_attrs_with_values())
+
+# Get attributes with their types
+print(explorer.get_attrs_with_types())
+
+# Get all classes
+print(explorer.get_classes())
+
+# Get all functions
+print(explorer.get_functions())
+
+# Get all builtins
+print(explorer.get_builtins())
+
+# Get all submodules
+print(explorer.get_modules())
+
+# Get detailed module info
+print(explorer.get_module_info())
+
+# Get statistics summary
+print(explorer.get_stats())
+
+# Get Python system info
+print(explorer.get_sys_info())
+
+# Get module file info
+print(explorer.get_file_info())
+
+# Get everything at once
+print(explorer.get_everything())
+```
+
+## Methods Reference
+
+| Method | Return Type | Description |
+|--------|-------------|-------------|
+| `get_all_attrs()` | `{'valid': bool, 'data': list}` | All attributes except dunder (`__xxx__`) |
+| `get_public_attrs()` | `{'valid': bool, 'data': list}` | Attributes not starting with `_` |
+| `get_private_attrs()` | `{'valid': bool, 'data': list}` | Attributes with single `_` prefix |
+| `get_dunder_attrs()` | `{'valid': bool, 'data': list}` | Dunder attributes (`__xxx__`) |
+| `get_callable_attrs()` | `{'valid': bool, 'data': list}` | Callable functions/methods |
+| `get_non_callable_attrs()` | `{'valid': bool, 'data': list}` | Non-callable variables/constants |
+| `get_attrs_with_values()` | `{'valid': bool, 'data': dict}` | Attribute names with their values |
+| `get_attrs_with_types()` | `{'valid': bool, 'data': dict}` | Attribute names with their types |
+| `get_classes()` | `{'valid': bool, 'data': list}` | All classes in the module |
+| `get_functions()` | `{'valid': bool, 'data': list}` | All functions in the module |
+| `get_builtins()` | `{'valid': bool, 'data': list}` | All built-in functions |
+| `get_modules()` | `{'valid': bool, 'data': list}` | All submodules imported |
+| `get_module_info()` | `{'valid': bool, 'data': dict}` | Module metadata (name, file, doc, etc.) |
+| `get_stats()` | `{'valid': bool, 'data': dict}` | Statistical summary of all attributes |
+| `get_sys_info()` | `{'valid': bool, 'data': dict}` | Python system information |
+| `get_file_info()` | `{'valid': bool, 'data': dict}` | Module source file information |
+| `get_everything()` | `{'valid': bool, 'data': dict}` | All information combined |
+
+## Return Format
+
+All methods return a dictionary with the following structure:
+
+```python
+{
+    'valid': True,          # bool: True if module is valid, False otherwise
+    'data': ...             # The actual data (list or dict)
+}
+```
+
+If the module is not valid, the method will:
+- Emit a `ValidNotTrueWarning` warning
+- Return `{'valid': False}`
+
+## Dependencies
+
+- Python 3.6+
+- `absence` library (automatically installed)
+
+## License
+
+MIT
+

get_module_underlying-0.0.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+_exceptions.py,sha256=oupQ3hSTPp1tniS5HHbI0jT1RUE2pkMfqVwBYesVIHQ,115
+get_module_underlying.py,sha256=UXdpTPbcqybrR2U3HjU7GSbr_n3HwDVTUbXOg0QyvQ4,10627
+get_module_underlying-0.0.1.dist-info/METADATA,sha256=wIpyTqb0Ysizf1Q1p0XQFM9z4_1wowwE3NlzdqHa-kU,3936
+get_module_underlying-0.0.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+get_module_underlying-0.0.1.dist-info/top_level.txt,sha256=oCnPXZ81vDPSEsmaVDpQfZ18n1NmUQMDrzLASAz6Pys,34
+get_module_underlying-0.0.1.dist-info/RECORD,,

get_module_underlying-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.45.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

get_module_underlying-0.0.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+_exceptions
+get_module_underlying

get_module_underlying.py

@@ -0,0 +1,296 @@
+# get_module_underlying.py
+
+import sys
+import __main__
+import os
+import types
+import warnings
+from _exceptions import ValidNotTrueWarning
+
+
+class ModuleExplorer:
+    """
+    Module explorer - goes deeper than dir()
+    """
+
+    def __init__(self, module_name=None):
+        self.name = module_name
+        self.module = None
+        self._valid = False
+        self._error = None
+
+        try:
+            import absence
+            from absence import absent
+        except ImportError as e:
+            self._error = str(e)
+            warnings.warn(f"Failed to import 'absence': {e}", ValidNotTrueWarning)
+            return
+
+        if module_name is None or module_name is absent:
+            self._error = "Module name cannot be None or absent."
+            warnings.warn(self._error, ValidNotTrueWarning)
+            return
+
+        self.name = module_name
+
+        if module_name in sys.modules:
+            self.module = sys.modules[module_name]
+            self._valid = True
+        else:
+            try:
+                self.module = __import__(module_name)
+                self._valid = True
+            except (ImportError, ModuleNotFoundError) as e:
+                self._error = str(e)
+                warnings.warn(f"Module '{module_name}' not found: {e}", ValidNotTrueWarning)
+                self.module = None
+                self._valid = False
+
+    def is_valid(self):
+        return self._valid
+
+    def _check_and_warn(self):
+        if not self._valid:
+            if self._error:
+                warnings.warn(self._error, ValidNotTrueWarning)
+            else:
+                warnings.warn(f"Module '{self.name}' is not valid.", ValidNotTrueWarning)
+            return False
+        return True
+
+    def get_all_attrs(self):
+        if not self._check_and_warn():
+            return {'valid': False}
+        return {
+            'valid': True,
+            'data': sorted([
+                k for k in dir(self.module)
+                if not (k.startswith('__') and k.endswith('__'))
+            ])
+        }
+
+    def get_public_attrs(self):
+        if not self._check_and_warn():
+            return {'valid': False}
+        return {
+            'valid': True,
+            'data': sorted([k for k in dir(self.module) if not k.startswith('_')])
+        }
+
+    def get_private_attrs(self):
+        if not self._check_and_warn():
+            return {'valid': False}
+        return {
+            'valid': True,
+            'data': sorted([
+                k for k in dir(self.module)
+                if k.startswith('_') and not (k.startswith('__') and k.endswith('__'))
+            ])
+        }
+
+    def get_dunder_attrs(self):
+        if not self._check_and_warn():
+            return {'valid': False}
+        return {
+            'valid': True,
+            'data': sorted([
+                k for k in dir(self.module)
+                if k.startswith('__') and k.endswith('__')
+            ])
+        }
+
+    def get_callable_attrs(self):
+        if not self._check_and_warn():
+            return {'valid': False}
+        result = []
+        for k in self.get_all_attrs()['data']:
+            try:
+                if callable(getattr(self.module, k)):
+                    result.append(k)
+            except Exception:
+                pass
+        return {'valid': True, 'data': sorted(result)}
+
+    def get_non_callable_attrs(self):
+        if not self._check_and_warn():
+            return {'valid': False}
+        result = []
+        for k in self.get_all_attrs()['data']:
+            try:
+                if not callable(getattr(self.module, k)):
+                    result.append(k)
+            except Exception:
+                pass
+        return {'valid': True, 'data': sorted(result)}
+
+    def get_attrs_with_values(self):
+        if not self._check_and_warn():
+            return {'valid': False}
+        result = {}
+        for k in self.get_all_attrs()['data']:
+            try:
+                result[k] = getattr(self.module, k)
+            except Exception:
+                result[k] = 'N/A'
+        return {'valid': True, 'data': result}
+
+    def get_attrs_with_types(self):
+        if not self._check_and_warn():
+            return {'valid': False}
+        result = {}
+        for k in self.get_all_attrs()['data']:
+            try:
+                v = getattr(self.module, k)
+                result[k] = type(v).__name__
+            except Exception:
+                result[k] = 'Unknown'
+        return {'valid': True, 'data': result}
+
+    def get_classes(self):
+        if not self._check_and_warn():
+            return {'valid': False}
+        result = []
+        for k in self.get_all_attrs()['data']:
+            try:
+                v = getattr(self.module, k)
+                if isinstance(v, type):
+                    result.append(k)
+            except Exception:
+                pass
+        return {'valid': True, 'data': sorted(result)}
+
+    def get_functions(self):
+        if not self._check_and_warn():
+            return {'valid': False}
+        result = []
+        for k in self.get_all_attrs()['data']:
+            try:
+                v = getattr(self.module, k)
+                if isinstance(v, types.FunctionType):
+                    result.append(k)
+            except Exception:
+                pass
+        return {'valid': True, 'data': sorted(result)}
+
+    def get_builtins(self):
+        if not self._check_and_warn():
+            return {'valid': False}
+        result = []
+        for k in self.get_all_attrs()['data']:
+            try:
+                v = getattr(self.module, k)
+                if isinstance(v, types.BuiltinFunctionType):
+                    result.append(k)
+            except Exception:
+                pass
+        return {'valid': True, 'data': sorted(result)}
+
+    def get_modules(self):
+        if not self._check_and_warn():
+            return {'valid': False}
+        result = []
+        for k in self.get_all_attrs()['data']:
+            try:
+                v = getattr(self.module, k)
+                if isinstance(v, types.ModuleType):
+                    result.append(k)
+            except Exception:
+                pass
+        return {'valid': True, 'data': sorted(result)}
+
+    def get_module_info(self):
+        if not self._check_and_warn():
+            return {'valid': False}
+        return {
+            'valid': True,
+            'data': {
+                'name': self.name,
+                'module_name': getattr(self.module, '__name__', None),
+                'file': getattr(self.module, '__file__', None),
+                'doc': getattr(self.module, '__doc__', None),
+                'package': getattr(self.module, '__package__', None),
+                'path': getattr(self.module, '__path__', None),
+                'loader': str(getattr(self.module, '__loader__', None)),
+                'spec': str(getattr(self.module, '__spec__', None)),
+                'cached': getattr(self.module, '__cached__', None),
+            }
+        }
+
+    def get_stats(self):
+        if not self._check_and_warn():
+            return {'valid': False}
+        all_data = self.get_all_attrs()['data']
+        return {
+            'valid': True,
+            'data': {
+                'total_attrs': len(all_data),
+                'public_count': len(self.get_public_attrs()['data']),
+                'private_count': len(self.get_private_attrs()['data']),
+                'dunder_count': len(self.get_dunder_attrs()['data']),
+                'callable_count': len(self.get_callable_attrs()['data']),
+                'non_callable_count': len(self.get_non_callable_attrs()['data']),
+                'class_count': len(self.get_classes()['data']),
+                'function_count': len(self.get_functions()['data']),
+                'builtin_count': len(self.get_builtins()['data']),
+                'submodule_count': len(self.get_modules()['data']),
+            }
+        }
+
+    def get_sys_info(self):
+        return {
+            'valid': True,
+            'data': {
+                'python_version': sys.version,
+                'platform': sys.platform,
+                'executable': sys.executable,
+                'argv': sys.argv,
+                'path': sys.path[:10],
+                'modules_loaded': len(sys.modules),
+            }
+        }
+
+    def get_file_info(self):
+        if not self._check_and_warn():
+            return {'valid': False}
+        filepath = getattr(self.module, '__file__', None)
+        if not filepath:
+            return {'valid': True, 'data': {'filepath': None, 'exists': False}}
+        return {
+            'valid': True,
+            'data': {
+                'filepath': filepath,
+                'exists': os.path.exists(filepath),
+                'is_file': os.path.isfile(filepath) if os.path.exists(filepath) else False,
+                'size': os.path.getsize(filepath) if os.path.exists(filepath) else None,
+                'dirname': os.path.dirname(filepath) if os.path.exists(filepath) else None,
+                'basename': os.path.basename(filepath) if os.path.exists(filepath) else None,
+            }
+        }
+
+    def get_everything(self):
+        if not self._check_and_warn():
+            return {'valid': False}
+        return {
+            'valid': True,
+            'data': {
+                'module_info': self.get_module_info()['data'],
+                'stats': self.get_stats()['data'],
+                'sys_info': self.get_sys_info()['data'],
+                'file_info': self.get_file_info()['data'],
+                'all_attrs': self.get_all_attrs()['data'],
+                'public_attrs': self.get_public_attrs()['data'],
+                'private_attrs': self.get_private_attrs()['data'],
+                'dunder_attrs': self.get_dunder_attrs()['data'],
+                'callable_attrs': self.get_callable_attrs()['data'],
+                'non_callable_attrs': self.get_non_callable_attrs()['data'],
+                'classes': self.get_classes()['data'],
+                'functions': self.get_functions()['data'],
+                'builtins': self.get_builtins()['data'],
+                'submodules': self.get_modules()['data'],
+                'attrs_with_values': self.get_attrs_with_values()['data'],
+                'attrs_with_types': self.get_attrs_with_types()['data'],
+            }
+        }
+__dir__ = [ModuleExplorer]
+__all__ = [ModuleExplorer]