uspector 1.0.0__tar.gz

uspector-1.0.0/.gitignore

@@ -0,0 +1,220 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+*.lcov
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# uv
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi/*
+!.pixi/config.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule*
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs/Zensical documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore that
+#   can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, you
+#   could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

uspector-1.0.0/.venv-test/.gitignore

@@ -0,0 +1,2 @@
+# Created by venv; see https://docs.python.org/3/library/venv.html
+*

uspector-1.0.0/.venv-test/Lib/site-packages/cffi/__init__.py

@@ -0,0 +1,14 @@
+__all__ = ['FFI', 'VerificationError', 'VerificationMissing', 'CDefError',
+           'FFIError']
+
+from .api import FFI
+from .error import CDefError, FFIError, VerificationError, VerificationMissing
+from .error import PkgConfigError
+
+__version__ = "2.1.1"
+__version_info__ = (2, 1, 1)
+
+# The verifier module file names are based on the CRC32 of a string that
+# contains the following version number.  It may be older than __version__
+# if nothing is clearly incompatible.
+__version_verifier_modules__ = "0.8.6"

uspector-1.0.0/.venv-test/Lib/site-packages/cffi/_cffi_errors.h

@@ -0,0 +1,135 @@
+#ifndef CFFI_MESSAGEBOX
+# ifdef _MSC_VER
+#  define CFFI_MESSAGEBOX  1
+# else
+#  define CFFI_MESSAGEBOX  0
+# endif
+#endif
+
+
+#if CFFI_MESSAGEBOX
+/* Windows only: logic to take the Python-CFFI embedding logic
+   initialization errors and display them in a background thread
+   with MessageBox.  The idea is that if the whole program closes
+   as a result of this problem, then likely it is already a console
+   program and you can read the stderr output in the console too.
+   If it is not a console program, then it will likely show its own
+   dialog to complain, or generally not abruptly close, and for this
+   case the background thread should stay alive.
+*/
+static void *volatile _cffi_bootstrap_text;
+
+static PyObject *_cffi_start_error_capture(void)
+{
+    PyObject *result = NULL;
+    PyObject *x, *m, *bi;
+
+    if (InterlockedCompareExchangePointer(&_cffi_bootstrap_text,
+            (void *)1, NULL) != NULL)
+        return (PyObject *)1;
+
+    m = PyImport_AddModule("_cffi_error_capture");
+    if (m == NULL)
+        goto error;
+
+    result = PyModule_GetDict(m);
+    if (result == NULL)
+        goto error;
+
+    bi = PyImport_ImportModule("builtins");
+    if (bi == NULL)
+        goto error;
+    PyDict_SetItemString(result, "__builtins__", bi);
+    Py_DECREF(bi);
+
+    x = PyRun_String(
+        "import sys\n"
+        "class FileLike:\n"
+        "  def write(self, x):\n"
+        "    try:\n"
+        "      of.write(x)\n"
+        "    except: pass\n"
+        "    self.buf += x\n"
+        "  def flush(self):\n"
+        "    pass\n"
+        "fl = FileLike()\n"
+        "fl.buf = ''\n"
+        "of = sys.stderr\n"
+        "sys.stderr = fl\n"
+        "def done():\n"
+        "  sys.stderr = of\n"
+        "  return fl.buf\n",   /* make sure the returned value stays alive */
+        Py_file_input,
+        result, result);
+    Py_XDECREF(x);
+
+ error:
+    if (PyErr_Occurred())
+    {
+        PyErr_WriteUnraisable(Py_None);
+        PyErr_Clear();
+    }
+    return result;
+}
+
+#pragma comment(lib, "user32.lib")
+
+static DWORD WINAPI _cffi_bootstrap_dialog(LPVOID ignored)
+{
+    Sleep(666);    /* may be interrupted if the whole process is closing */
+    MessageBoxW(NULL, (wchar_t *)_cffi_bootstrap_text,
+                L"Python-CFFI error",
+                MB_OK | MB_ICONERROR);
+    _cffi_bootstrap_text = NULL;
+    return 0;
+}
+
+static void _cffi_stop_error_capture(PyObject *ecap)
+{
+    PyObject *s;
+    void *text;
+
+    if (ecap == (PyObject *)1)
+        return;
+
+    if (ecap == NULL)
+        goto error;
+
+    s = PyRun_String("done()", Py_eval_input, ecap, ecap);
+    if (s == NULL)
+        goto error;
+
+    /* Show a dialog box, but in a background thread, and
+       never show multiple dialog boxes at once. */
+    text = PyUnicode_AsWideCharString(s, NULL);
+
+    _cffi_bootstrap_text = text;
+
+    if (text != NULL)
+    {
+        HANDLE h;
+        h = CreateThread(NULL, 0, _cffi_bootstrap_dialog,
+                         NULL, 0, NULL);
+        if (h != NULL)
+            CloseHandle(h);
+    }
+    /* decref the string, but it should stay alive as 'fl.buf'
+       in the small module above.  It will really be freed only if
+       we later get another similar error.  So it's a leak of at
+       most one copy of the small module.  That's fine for this
+       situation which is usually a "fatal error" anyway. */
+    Py_DECREF(s);
+    PyErr_Clear();
+    return;
+
+  error:
+    _cffi_bootstrap_text = NULL;
+    PyErr_Clear();
+}
+
+#else
+
+static PyObject *_cffi_start_error_capture(void) { return NULL; }
+static void _cffi_stop_error_capture(PyObject *ecap) { }
+
+#endif

uspector-1.0.0/.venv-test/Lib/site-packages/cffi/_cffi_gen_src.py

@@ -0,0 +1,216 @@
+# Integrated from the cffi-buildtool project by Rose Davidson
+# (https://github.com/inklesspen/cffi-buildtool), under the following
+# license:
+#
+# MIT License
+#
+# Copyright (c) 2024, Rose Davidson
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice (including the
+# next paragraph) shall be included in all copies or substantial portions
+# of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+"""Implementation of the ``cffi-gen-src`` command-line tool.
+
+This module is private; the command line is the only supported
+interface. Two subcommands:
+
+``exec-python``
+    Execute a Python script that constructs a :class:`cffi.FFI`
+    (the same kind of script that the CFFI docs' "Main mode of usage"
+    describes) and emit the generated C source.
+
+``read-sources``
+    Create the :class:`cffi.FFI` from a separate ``cdef`` file and C
+    source prelude, then emit the generated C source.
+"""
+
+import argparse
+import io
+import os
+import sys
+
+from .api import FFI
+
+
+def _execfile(pysrc, filename, globs):
+    compiled = compile(source=pysrc, filename=filename, mode='exec')
+    exec(compiled, globs, globs)
+
+
+def find_ffi_in_python_script(pysrc, filename, ffivar):
+    """Execute ``pysrc`` and return the :class:`FFI` object it defines.
+
+    The script is executed with ``__name__`` set to ``"cffi.gen_src"``,
+    so a trailing ``if __name__ == "__main__": ffibuilder.compile()``
+    block in the script is skipped.
+
+    ``ffivar`` is the name bound by the script to the :class:`FFI`
+    object, or to a callable that returns one.
+
+    Raises :class:`NameError` if the name is not bound by the script,
+    or :class:`TypeError` if the name does not resolve to an
+    :class:`FFI` instance.
+    """
+    filename = os.path.abspath(filename)
+    globs = {'__name__': 'cffi.gen_src', '__file__': filename}
+    old_path = sys.path[:]
+    sys.path.insert(0, os.path.dirname(filename))
+    try:
+        _execfile(pysrc, filename, globs)
+        if ffivar not in globs:
+            raise NameError(
+                "Expected to find the FFI object with the name %r, "
+                "but it was not found." % (ffivar,)
+            )
+        ffi = globs[ffivar]
+        if not isinstance(ffi, FFI) and callable(ffi):
+            # Maybe it's a callable that returns a FFI
+            ffi = ffi()
+        if not isinstance(ffi, FFI):
+            raise TypeError(
+                "Found an object with the name %r but it was not an "
+                "instance of cffi.api.FFI" % (ffivar,)
+            )
+        return ffi
+    finally:
+        sys.path[:] = old_path
+
+
+def make_ffi_from_sources(modulename, cdef, csrc):
+    """Create an :class:`FFI` from ``cdef`` text and a C source prelude."""
+    ffibuilder = FFI()
+    ffibuilder.cdef(cdef)
+    ffibuilder.set_source(modulename, csrc)
+    return ffibuilder
+
+
+def generate_c_source(ffi):
+    """Return the C source that :meth:`FFI.emit_c_code` would write."""
+    output = io.StringIO()
+    ffi.emit_c_code(output)
+    return output.getvalue()
+
+
+def write_c_source(output, generated):
+    if output == '-':
+        sys.stdout.write(generated)
+        return
+    with open(output, 'w', encoding='utf-8') as f:
+        f.write(generated)
+
+
+def same_input_file(file1, file2):
+    if file1 is file2:
+        return True
+    try:
+        return os.path.samefile(file1.name, file2.name)
+    except OSError:
+        return False
+
+
+def exec_python(*, output, pyfile, ffi_var):
+    with pyfile:
+        ffi = find_ffi_in_python_script(pyfile.read(), pyfile.name, ffi_var)
+    generated = generate_c_source(ffi)
+    write_c_source(output, generated)
+
+
+def read_sources(*, output, module_name, cdef_input, csrc_input):
+    with csrc_input, cdef_input:
+        csrc = csrc_input.read()
+        cdef = cdef_input.read()
+    ffi = make_ffi_from_sources(module_name, cdef, csrc)
+    generated = generate_c_source(ffi)
+    write_c_source(output, generated)
+
+
+def _prog():
+    # The same parser serves both documented invocations; make --help
+    # and usage messages show the one that was actually used.
+    argv0 = os.path.basename(sys.argv[0]) if sys.argv else ''
+    if argv0.startswith('cffi-gen-src'):
+        return 'cffi-gen-src'
+    return 'python -m cffi.gen_src'
+
+
+parser = argparse.ArgumentParser(
+    prog=_prog(),
+    description='Generate CFFI C source for extension modules.',
+)
+subparsers = parser.add_subparsers(dest='mode')
+
+exec_python_parser = subparsers.add_parser(
+    'exec-python',
+    help='Execute a Python script that defines an FFI object',
+)
+exec_python_parser.add_argument(
+    '--ffi-var',
+    default='ffibuilder',
+    help="Name of the FFI object in the Python script; defaults to 'ffibuilder'.",
+)
+exec_python_parser.add_argument(
+    'pyfile',
+    type=argparse.FileType('r', encoding='utf-8'),
+    help='Path to the Python script',
+)
+exec_python_parser.add_argument(
+    'output',
+    help='Output path for the C source',
+)
+
+read_sources_parser = subparsers.add_parser(
+    'read-sources',
+    help='Read cdef and C source prelude files that define an FFI object',
+)
+read_sources_parser.add_argument(
+    'module_name',
+    help='Full name of the generated module, including packages',
+)
+read_sources_parser.add_argument(
+    'cdef',
+    type=argparse.FileType('r', encoding='utf-8'),
+    help='File containing C definitions',
+)
+read_sources_parser.add_argument(
+    'csrc',
+    type=argparse.FileType('r', encoding='utf-8'),
+    help='File containing C source prelude',
+)
+read_sources_parser.add_argument(
+    'output',
+    help='Output path for the C source',
+)
+
+
+def run(args=None):
+    args = parser.parse_args(args=args)
+    if args.mode == 'exec-python':
+        exec_python(output=args.output, pyfile=args.pyfile, ffi_var=args.ffi_var)
+    elif args.mode == 'read-sources':
+        if same_input_file(args.cdef, args.csrc):
+            parser.error('cdef and csrc are the same file and should not be')
+        read_sources(
+            output=args.output,
+            module_name=args.module_name,
+            cdef_input=args.cdef,
+            csrc_input=args.csrc,
+        )
+    else:
+        parser.error('a subcommand is required: exec-python or read-sources')
+    parser.exit(0)