cavisson-pythonagent 0.0.1__py3-none-any.whl

pythonagent/agent/probes/Instrumentation/__init__.py

@@ -0,0 +1,340 @@
+from ..base import ExitCallInterceptor
+from pythonagent.agent.probes.Instrumentation.parser import create_method_array
+from pythonagent.agent.probes.Instrumentation.new_parser import create_method_list
+
+# from pythonagent.agent.probes.havoc.havoc_manager import NDNetHavocMonitor
+from pythonagent.utils import get_current_timestamp_in_ms, get_current_timestamp_in_us, get_validated_duration,get_current_thread_time_in_us
+
+import os
+import configparser
+import time
+import threading
+import sysconfig
+import warnings
+import sys
+
+# Thread-local flag: prevents _custom_method from re-entering itself when an
+# instrumented method (e.g. logging.Logger.debug) is called from within the
+# wrapper. Without this guard a complete-AD profile that includes stdlib logger
+# methods causes infinite recursion → C-stack overflow → SIGSEGV.
+_nd_instr_active = threading.local()
+
+# ALL Python data-model (dunder) methods — must never be instrumented.
+# Wrapping operator methods (__or__, __and__, etc.) corrupts enum/flag
+# semantics (Crash 2). Wrapping __getattr__/__getattribute__ causes
+# infinite recursion on every attribute access.
+_DUNDER_SKIP = frozenset([
+    # attribute access
+    '__getattr__', '__getattribute__', '__setattr__', '__delattr__',
+    # descriptor protocol
+    '__get__', '__set__', '__delete__',
+    # object lifecycle and class creation
+    '__new__', '__init__', '__del__', '__call__',
+    '__init_subclass__', '__class_getitem__', '__instancecheck__', '__subclasscheck__',
+    # string representations
+    '__repr__', '__str__', '__format__', '__bytes__',
+    # comparison and hashing
+    '__eq__', '__ne__', '__lt__', '__le__', '__gt__', '__ge__', '__hash__',
+    # boolean / numeric type conversions
+    '__bool__', '__int__', '__float__', '__complex__', '__index__',
+    '__round__', '__trunc__', '__floor__', '__ceil__', '__abs__', '__neg__', '__pos__',
+    # arithmetic operators
+    '__add__', '__radd__', '__iadd__',
+    '__sub__', '__rsub__', '__isub__',
+    '__mul__', '__rmul__', '__imul__',
+    '__truediv__', '__rtruediv__', '__itruediv__',
+    '__floordiv__', '__rfloordiv__', '__ifloordiv__',
+    '__mod__', '__rmod__', '__imod__',
+    '__pow__', '__rpow__', '__ipow__',
+    '__divmod__', '__rdivmod__',
+    # bitwise / logical operators — caused Crash 2 (re.I | re.ASCII)
+    '__or__', '__ror__', '__ior__',
+    '__and__', '__rand__', '__iand__',
+    '__xor__', '__rxor__', '__ixor__',
+    '__lshift__', '__rlshift__', '__ilshift__',
+    '__rshift__', '__rrshift__', '__irshift__',
+    '__invert__',
+    # container protocol
+    '__len__', '__length_hint__', '__iter__', '__reversed__', '__next__',
+    '__contains__', '__getitem__', '__setitem__', '__delitem__', '__missing__',
+    # context managers
+    '__enter__', '__exit__', '__aenter__', '__aexit__',
+    # async iterators / generators
+    '__await__', '__aiter__', '__anext__',
+    # pickle / copy
+    '__reduce__', '__reduce_ex__', '__copy__', '__deepcopy__',
+    # misc
+    '__sizeof__', '__dir__',
+])
+
+
+def _build_stdlib_realpath():
+    p = sysconfig.get_path('stdlib')
+    return os.path.realpath(p) if p else None
+
+_STDLIB_REALPATH = _build_stdlib_realpath()
+
+# Fallback prefix set used when sysconfig cannot determine the stdlib path.
+_FALLBACK_STDLIB_NAMES = frozenset([
+    'logging', 'os', 'sys', 'io', 'abc', 'threading', 'collections',
+    'functools', 'importlib', 'types', 'traceback', 'inspect',
+    'contextlib', 'weakref', 'copyreg', '_io', '_thread',
+    're', 'enum', 'email', 'html', 'xml',
+    'json', 'csv', 'hashlib', 'hmac', 'ssl', 'socket', 'select',
+    'struct', 'codecs', 'string', 'textwrap', 'unicodedata',
+    'pythonagent',
+])
+
+
+def _is_stdlib_module(mod):
+    """Return True if mod is from the Python standard library or is a built-in."""
+    mod_file = getattr(mod, '__file__', None)
+    if mod_file is None:
+        return True  # built-in C extension — no file, always skip
+    if _STDLIB_REALPATH:
+        return os.path.realpath(mod_file).startswith(_STDLIB_REALPATH)
+    return mod.__name__.split('.')[0] in _FALLBACK_STDLIB_NAMES
+
+
+# Top-level packages that are pure protocol/serialization/transport-layer
+# plumbing for libraries that already have a dedicated exit-call probe
+# (pymongo, requests, httpx, aiohttp, ...). Generically instrumenting these
+# adds no tracing value -- they're never application/business logic -- and is
+# actively harmful: their calls happen nested *inside* a DB/HTTP exit call's
+# own begin/end window (e.g. bson encoding a query inside a pymongo command,
+# or a TLS handshake inside a requests/httpx call), and interleaving extra
+# native-SDK method_entry/method_exit calls in there corrupts the exit call's
+# own callout ("T record") tracking. Excluding them here loses nothing: the
+# dedicated probe for the library that actually uses them still captures the
+# real DB/HTTP call.
+_PLUMBING_PACKAGE_DENYLIST = frozenset([
+    'bson',               # pymongo's BSON serialization
+    'cryptography',       # TLS, used by requests/urllib3/httpx/pymongo
+    'dns',                # dnspython -- hostname/SRV resolution (pymongo etc.)
+    'h11',                # HTTP/1.1 protocol implementation (httpx/httpcore)
+    'httpcore',           # httpx's transport layer
+    'attr',               # attrs metaprogramming, used by dns/httpx/etc.
+    'anyio',              # async compat layer (httpx/starlette)
+    'sniffio',            # async library detection (anyio/httpx)
+    'multidict',          # used by aiohttp/yarl
+    'yarl',               # URL parsing (aiohttp)
+    'frozenlist',         # used by aiohttp
+    'aiosignal',          # used by aiohttp
+    'propcache',          # used by yarl/aiohttp
+    'charset_normalizer', # encoding detection (requests)
+    'idna',               # internationalized domain names (requests/urllib3/dns)
+    'certifi',            # CA bundle (requests/urllib3)
+])
+
+
+class MethodInterceptor(ExitCallInterceptor):
+
+    def _custom_method(self, original_method, *args, **kwargs):
+        # Reentrancy guard: prevents _custom_method from re-entering itself
+        # when the agent's OWN bookkeeping code (self.agent.logger.*,
+        # havoc_monitor.*, method_entry/method_exit) ends up calling back into
+        # an instrumented method. It must NOT cover the call to the real
+        # wrapped method below -- that's where the application's own nested
+        # calls happen (e.g. a Flask view function calling another
+        # instrumented helper), and those need to be measured normally. See
+        # _custom_method_inner for where the guard is actually held.
+        if getattr(_nd_instr_active, 'active', False):
+            return original_method(*args, **kwargs)
+        return self._custom_method_inner(original_method, *args, **kwargs)
+
+    def _custom_method_inner(self, original_method, *args, **kwargs):
+        bt = self.bt
+        before_time = 0
+        cpu_time_before = 0
+        cpu_time = 0
+
+        if hasattr(self.cls, "__module__"):  # Class Level Method
+            fqmforentry = self.cls.__module__ + "." + self.cls.__name__ + "." + str(original_method.__name__)
+        else:  # Module Level Method
+            fqmforentry = self.cls.__name__ + "." + original_method.__name__
+
+        if bt is not None:
+            # Guard is held ONLY around the agent's own entry-side bookkeeping,
+            # not around the real method call below.
+            _nd_instr_active.active = True
+            try:
+                try:
+                    from pythonagent.agent.probes.havoc.havoc_manager import NDNetHavocMonitor, NDHavocException
+                    havoc_monitor = NDNetHavocMonitor.get_instance()
+                    before_time = get_current_timestamp_in_us()
+                    cpu_time_before = get_current_thread_time_in_us()
+                    if self.agent.logger.isEnabledFor(10):
+                        self.agent.logger.debug("calling method entry bt %s fqm %s start_time %s", bt, fqmforentry, before_time)
+                    self.agent.method_entry(bt, fqmforentry, before_time)
+
+                except Exception as e:
+                    self.agent.logger.exception('exception in MethodInterceptor._custom_method entry part: {}'.format(e))
+
+                try:
+                    context = self.agent.get_transaction_context()
+                    btname = context.btname if context else None
+                    req_url = context.url_path if context else None
+                    havoc_monitor.apply_method_call_delay(fqmforentry, req_url, btname)
+                    havoc_monitor.apply_method_invocation_failure(fqmforentry, req_url, btname)
+
+                except Exception as e:
+                    if isinstance(e, NDHavocException):
+                        try:
+                            cpu_time_after = get_current_thread_time_in_us()
+                            after_time = get_current_timestamp_in_us()
+                            cpu_time = cpu_time_after - cpu_time_before
+                            duration = get_validated_duration(before_time, after_time, fqmforentry)
+                            self.agent.logger.debug("calling method exit for havoc bt {} fqm {} duration {} cpu_time {} start_time {}".format(bt, fqmforentry, duration, cpu_time, before_time))
+                            self.agent.set_current_status_code(503)
+                            self.agent.method_exit(bt, fqmforentry, duration, cpu_time, before_time)
+                        except Exception as exit_exception:
+                            self.agent.logger.exception('exception in MethodInterceptor._custom_method havoc exit part: {}'.format(exit_exception))
+                        raise
+                    else:
+                        self.agent.logger.debug("Non-Havoc Exception {}".format(e))
+            finally:
+                _nd_instr_active.active = False
+
+            # Guard is OFF here: this is the actual application call, which may
+            # itself call other instrumented methods -- those must be measured.
+            response = original_method(*args, **kwargs)
+
+            _nd_instr_active.active = True
+            try:
+                try:
+                    cpu_time_after = get_current_thread_time_in_us()
+                    after_time = get_current_timestamp_in_us()
+                    cpu_time = cpu_time_after - cpu_time_before
+                    duration = get_validated_duration(before_time, after_time, fqmforentry)
+
+                except Exception as e:
+                    self.agent.logger.exception('exception in MethodInterceptor._custom_method exit initial part: {}'.format(e))
+
+                try:
+                    self.agent.logger.debug("calling method exit for native bt {} fqm {} duration {} cpu_time {} start_time {}".format(bt, fqmforentry, duration, cpu_time, before_time))
+                    self.agent.method_exit(bt, fqmforentry, duration, cpu_time, before_time)
+                except Exception as e:
+                    self.agent.logger.exception('exception in MethodInterceptor._custom_method exit later part: {}'.format(e))
+            finally:
+                _nd_instr_active.active = False
+
+        else:
+            if self.agent.logger.isEnabledFor(10):
+                self.agent.logger.debug('MethodInterceptor._custom_method: no active BT for fqm %s, calling through uninstrumented', fqmforentry)
+            response = original_method(*args, **kwargs)
+
+        return response
+
+
+def _sync_flask_view_functions(mod, agent):
+    """After patching mod.* attributes, update Flask's view_functions to point to the wrappers.
+
+    Flask stores direct function-object references in app.view_functions at route-registration
+    time. setattr(mod, name, wrapper) replaces the module attribute but Flask's routing table
+    still holds the original. This walk finds Flask app objects in the module and re-points
+    their view_functions entries to the now-patched module attributes.
+
+    Safety check: this is called from intercept_instrumented_method() for every
+    instrumented module regardless of framework, so it must be a strict no-op
+    for apps that don't use Flask at all -- both when the flask package isn't
+    installed, and when it's installed (e.g. as an unused transitive
+    dependency) but never actually imported/used by this process.
+    """
+    if 'flask' not in sys.modules:
+        return
+    try:
+        from flask import Flask
+    except ImportError:
+        return
+    try:
+        for attr_val in vars(mod).values():
+            if not isinstance(attr_val, Flask):
+                continue
+            for endpoint, orig_func in list(attr_val.view_functions.items()):
+                if getattr(orig_func, '__module__', None) != mod.__name__:
+                    continue
+                patched = getattr(mod, orig_func.__name__, None)
+                if patched is not None and patched is not orig_func:
+                    attr_val.view_functions[endpoint] = patched
+                    if agent.logger.isEnabledFor(10):
+                        agent.logger.debug(
+                            "Synced Flask view_functions[%s] to patched wrapper", endpoint)
+    except Exception as e:
+        agent.logger.warning("Could not sync Flask view_functions for %s: %s", mod.__name__, e)
+
+
+def intercept_instrumented_method(agent, mod):
+
+    custom_methods_to_instrument = agent.custom_methods_to_instrument
+    package_and_module = mod.__name__
+
+    # Never instrument stdlib modules: their methods are called internally by
+    # _custom_method (logger, enum operators, etc.) and wrapping them causes
+    # crashes ranging from infinite recursion (Crash 1) to enum ValueError (Crash 2).
+    if _is_stdlib_module(mod):
+        return
+
+    # Also skip the agent's own internals regardless of install path.
+    if package_and_module.startswith('pythonagent'):
+        return
+
+    # Skip known protocol/serialization plumbing that's a dependency of a
+    # library with its own dedicated exit-call probe -- see
+    # _PLUMBING_PACKAGE_DENYLIST for why.
+    if package_and_module.split('.')[0] in _PLUMBING_PACKAGE_DENYLIST:
+        return
+
+    for item in custom_methods_to_instrument:
+        if not item.startswith(package_and_module + '.'):
+            continue
+
+        class_and_method = item[len(package_and_module)+1:]
+        split = class_and_method.split(".")
+        if len(split) > 1:                                                              # Class Level Method
+            class_name = split[0]
+            method_name = split[1]
+            if method_name in _DUNDER_SKIP:
+                continue
+            try:
+                # Suppress deprecation/runtime warnings emitted by getattr on legacy
+                # third-party classes (e.g. cryptography's Blowfish, IDEA, CAST5).
+                with warnings.catch_warnings():
+                    warnings.simplefilter("ignore")
+                    cls = getattr(mod, class_name)
+                MethodInterceptor(agent, cls).attach(method_name, wrapper_func=None, patched_method_name='_custom_method')
+            except AttributeError:
+                # Profile depth may be off by one: class_name might be a sub-module that
+                # hasn't been imported into the parent's namespace yet (e.g. the instrprof.json
+                # records module=pkg, class=submod, method=ActualClass instead of
+                # module=pkg.submod, class=ActualClass, method=actual_method).
+                # Try resolving pkg.submod from sys.modules and shift the path down one level.
+                sub_mod = sys.modules.get(package_and_module + '.' + class_name)
+                if sub_mod is not None and len(split) > 2:
+                    real_class_name = method_name
+                    real_method_name = split[2]
+                    if real_method_name not in _DUNDER_SKIP:
+                        try:
+                            with warnings.catch_warnings():
+                                warnings.simplefilter("ignore")
+                                real_cls = getattr(sub_mod, real_class_name)
+                            MethodInterceptor(agent, real_cls).attach(real_method_name, wrapper_func=None, patched_method_name='_custom_method')
+                        except Exception as e2:
+                            agent.logger.warning("Could not instrument %s.%s.%s.%s: %s", package_and_module, class_name, real_class_name, real_method_name, e2)
+                else:
+                    agent.logger.warning("Could not instrument METHOD OF CLASS %s, %s, %s : module '%s' has no attribute '%s'", package_and_module, class_name, method_name, package_and_module, class_name)
+            except Exception as e:
+                agent.logger.warning("Could not instrument METHOD OF CLASS %s, %s, %s : %s", package_and_module, class_name, method_name, e)
+        else:                                                                           # Module Level Method
+            method_name = split[0]
+            if method_name in _DUNDER_SKIP:
+                continue
+            try:
+                MethodInterceptor(agent, mod).attach(method_name, wrapper_func=None, patched_method_name='_custom_method')
+            except Exception as e:
+                agent.logger.warning("Could not instrument %s.%s: %s", package_and_module, method_name, e)
+
+    # After patching module attributes, sync Flask's routing table so that HTTP
+    # dispatch also goes through the wrappers (Flask stores direct function-object
+    # refs in view_functions, not module attribute lookups).
+    _sync_flask_view_functions(mod, agent)
+

pythonagent/agent/probes/Instrumentation/find.py

@@ -0,0 +1,243 @@
+import os
+import ast
+import json
+import ctypes
+import sys
+import time
+import pyclbr
+import datetime
+from pythonagent.agent.internal.proc_compat import get_process_name
+from pythonagent.agent.probes.Instrumentation import module_version_resolver
+import hashlib
+import inspect
+
+
+def newmodulefinder():
+    import sys
+    from modulefinder import ModuleFinder
+    finder = ModuleFinder()
+    #finder.run_script(sys.argv[0])
+    modulelist = []
+    module_dict = {}
+    # print('Loaded modules:')
+
+    #for name, mod in finder.modules.items():
+    for name, mod in sys.modules.items():
+        #print("name {}".format(name))
+        #print("mod {}".format(mod.__dict__))
+
+        #if mod.__file__ is None:
+        if not hasattr(mod, "__file__"):
+            pass
+        else:
+            module_dict[mod.__name__] = mod.__file__
+            #modulelist.append(mod.__file__)
+            #print(mod.__name__)
+    return module_dict
+
+
+import re
+
+
+def regex_match(list_of_regex, expression):
+    for regex in list_of_regex:
+        if re.search(str(regex), expression, re.IGNORECASE):
+            return 1
+    else:
+        return 0
+
+
+def cls_mett_find(node, package_and_module, f, method_filter_list, class_filter_list, jar_field=''):
+    outfromad = ""
+    num_of_methods = 0
+
+    functions = []
+    classes = []
+
+    if not method_filter_list and not class_filter_list:  # Case 1: No Method Filter and No Class filter
+        for n in node.body:
+            if isinstance(n, ast.FunctionDef):
+                functions.append(n)
+            if isinstance(n, ast.ClassDef):
+                classes.append(n)
+
+    elif method_filter_list and not class_filter_list:  # Case 2: Only Method Filter
+        for n in node.body:
+            if isinstance(n, ast.FunctionDef) and regex_match(method_filter_list, n.name):
+                functions.append(n)
+            if isinstance(n, ast.ClassDef):
+                for t in n.body:
+                    if isinstance(t, ast.FunctionDef) and regex_match(method_filter_list, t.name):
+                        classes.append(n)
+                        break  # Bug 3 fix: append the class once, not once per matching method
+
+    elif not method_filter_list and class_filter_list:  # Case 3: Only Class Filter
+        for n in node.body:
+            if isinstance(n, ast.ClassDef) and regex_match(class_filter_list, n.name):
+                classes.append(n)
+
+    elif method_filter_list and class_filter_list:  # Case 4: Both Method and Class Filter
+        for n in node.body:
+            if isinstance(n, ast.FunctionDef) and regex_match(method_filter_list, n.name):
+                functions.append(n)
+
+            if isinstance(n, ast.ClassDef) and regex_match(class_filter_list, n.name):
+                for t in n.body:
+                    if isinstance(t, ast.FunctionDef) and regex_match(method_filter_list, t.name):
+                        classes.append(n)
+
+    lif = []
+    for function in functions:
+        if type(function.name)==str:
+            lif.append(function.name)
+            num_of_methods = len(lif)
+    joined_string = ",".join(lif)
+
+    if len(joined_string)>0:
+        # 4th field after methods is the jar-name-equivalent field (mirrors the NodeJS/Java sibling
+        # agents' module|methods|interface|jar layout): "<pkgName>@<pkgVersion>", suffixed "(app)"
+        # when the file belongs to the monitored application itself, or blank if unresolved.
+        outfromad = package_and_module + "||" + joined_string + "|" + jar_field + "\n"
+        """
+        if pkgname:
+            #print("if pkgname")
+            if module_name == "__init__":
+                #print("if module init")
+                outfromad = pkgname+"||"+joined_string+"\n" 
+            else:
+                #print("else module init")
+                outfromad = pkgname+"."+module_name+"||"+joined_string+"\n" 
+        else:
+            #print("else pkgname")
+            outfromad = module_name+"||"+joined_string+"\n"
+        """
+        #print("outfromad:", outfromad)
+        #f.writelines(outfromad)
+        """
+        try:
+            outfromad = pkgname+"."+module_name+"||"+joined_string+"\n" 
+            f.writelines(pkgname+"."+module_name+"||"+joined_string+"\n")
+        except:
+            outfromad = module_name+"||"+joined_string+"\n"
+            f.writelines(module_name+"||"+joined_string+"\n")
+        """
+    #if module_name == "app":
+    #    print("outfromad : {}".format(outfromad))
+
+    for class_ in classes:
+        li = []
+        all_methods = [n for n in class_.body if isinstance(n, ast.FunctionDef)]
+        methods = []
+        if method_filter_list:
+            for method in all_methods:
+                if regex_match(method_filter_list, method.name):
+                    methods.append(method)
+        else:
+            methods = all_methods
+
+        if len(methods)>0:
+            for method in methods:
+                if type(method.name)==str:
+                    li.append(method.name)
+            num_of_methods += len(li)
+            joined_stringf = ",".join(li)
+            #if "flask" in pkgname:
+            #    print("joined_stringf", joined_stringf)
+            if len(joined_stringf)>0:
+                outfromad += package_and_module + "|" + class_.name + "|" + joined_stringf + "|" + jar_field + "\n"
+
+                """
+                if pkgname:
+                    #print("if pkgname")
+                    if module_name == "__init__":
+                        
+                        #outfromad += "\n"+pkgname+"|"+class_.name+"|"+joined_stringf+"\n" 
+                        outfromad += pkgname+"|"+class_.name+"|"+joined_stringf+"\n" 
+                        
+                    else:
+                        #print("else module init")
+                        #outfromad += "\n"+pkgname+"."+module_name+"|"+class_.name+"|"+joined_stringf+"\n" 
+                        outfromad += pkgname+"."+module_name+"|"+class_.name+"|"+joined_stringf+"\n" 
+                else:
+                    #print("else pkgname")
+                    #outfromad += "\n"+module_name+"|"+class_.name+"|"+joined_stringf+"\n"
+                    outfromad += module_name+"|"+class_.name+"|"+joined_stringf+"\n"
+                """
+
+            """
+            try:
+                outfromad += "\n"+pkgname+"."+module_name+"|"+class_.name+"|"+joined_stringf+"\n"
+                f.writelines(pkgname+"."+module_name+"|"+class_.name+"|"+joined_stringf+"\n")
+            except:
+                outfromad += "\n"+module_name+"|"+class_.name+"|"+joined_stringf+"\n"
+                f.writelines(module_name+"|"+class_.name+"|"+joined_stringf+"\n")
+            """ 
+    f.writelines(outfromad)
+    return outfromad,num_of_methods
+
+
+def find(method_filter_list, class_filter_list):
+    complete_output_str = ""
+    procname = get_process_name()
+    ndhome = os.environ.get("NDHOME")
+    #pathforfile = ndhome + "/python/logs/"
+    pathforfile = "/tmp/"
+    filename = str(procname + "_AD.txt")
+    file_to_open = os.path.join(pathforfile, filename)
+    f = open(file_to_open, "w")
+    f.writelines(
+        "************************************  AUTO-DISCOVERY  **************************************** \n"
+    )
+    nylist = newmodulefinder()
+    num_of_modules = len(nylist)
+    num_of_methods = 0
+
+    for package_and_module, path in nylist.items():
+        # Bug 6: use os.path for cross-platform __main__ name extraction
+        if package_and_module == "__main__":
+            package_and_module = os.path.splitext(os.path.basename(path))[0]
+
+        # Bug 2: skip None paths and non-Python source files (C extensions, .pyc, etc.)
+        if not path or not path.endswith('.py'):
+            continue
+
+        # Bug 1: reset node so a parse failure never bleeds into the next module
+        node = None
+        try:
+            with open(path) as ff:
+                node = ast.parse(ff.read())
+        except Exception as e:
+            pass
+
+        if node is None:
+            continue
+
+        try:
+            pkg_info = module_version_resolver.resolve(path)
+            jar_field = module_version_resolver.format_jar_field(pkg_info)
+        except Exception as e:
+            jar_field = ''
+
+        try:
+            outputfromaf, methodscount = cls_mett_find(node, package_and_module, f, method_filter_list,
+                                                       class_filter_list, jar_field)
+        except Exception as e:
+            print(e)
+        
+        try:
+            num_of_methods+=methodscount
+            complete_output_str+=outputfromaf
+        except:
+            pass
+
+        #print("TOTAL METHODS ",num_of_methods)
+    
+
+    return complete_output_str, num_of_modules, num_of_methods
+
+
+
+if __name__ == "__main__":
+    find()
+
+