real-ladybug 0.0.1.dev1__cp312-cp312-win_amd64.whl

real_ladybug-source/scripts/pip-package/package_tar.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+
+import os
+import shutil
+import subprocess
+import sys
+import tarfile
+from tempfile import TemporaryDirectory
+
+base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+def _get_lbug_version():
+    cmake_file = os.path.abspath(os.path.join(base_dir, "..", "CMakeLists.txt"))
+    with open(cmake_file) as f:
+        for line in f:
+            if line.startswith("project(Lbug VERSION"):
+                raw_version = line.split(" ")[2].strip()
+                version_nums = raw_version.split(".")
+                if len(version_nums) <= 3:
+                    return raw_version
+                else:
+                    dev_suffix = version_nums[3]
+                    version = ".".join(version_nums[:3])
+                    version += ".dev%s" % dev_suffix
+                    return version
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 2:
+        file_name = sys.argv[1]
+    else:
+        file_name = "real_ladybug-%s.tar.gz" % _get_lbug_version()
+    print("Creating %s..." % file_name)
+
+    with TemporaryDirectory() as tempdir:
+        subprocess.check_call(
+            [
+                "git",
+                "archive",
+                "--format",
+                "tar",
+                "-o",
+                os.path.join(tempdir, "real_ladybug-source.tar"),
+                "HEAD",
+            ],
+            cwd="../..",
+        )
+
+        with tarfile.open(os.path.join(tempdir, "real_ladybug-source.tar")) as tar:
+            tar.extractall(path=os.path.join(tempdir, "real_ladybug-source"), filter=None)
+
+        os.remove(os.path.join(tempdir, "real_ladybug-source.tar"))
+
+        # Remove components that are not needed for the pip package
+        shutil.rmtree(os.path.join(tempdir, "real_ladybug-source/dataset"))
+        shutil.rmtree(os.path.join(tempdir, "real_ladybug-source/examples"))
+        shutil.rmtree(os.path.join(tempdir, "real_ladybug-source/benchmark"))
+        shutil.rmtree(os.path.join(tempdir, "real_ladybug-source/logo"))
+        shutil.rmtree(os.path.join(tempdir, "real_ladybug-source/extension"))
+        shutil.rmtree(os.path.join(tempdir, "real_ladybug-source/test"))
+        shutil.rmtree(os.path.join(tempdir, "real_ladybug-source/.github"))
+
+        os.makedirs(os.path.join(tempdir, "real_ladybug"))
+        for path in ["setup.py", "setup.cfg", "MANIFEST.in"]:
+            shutil.copy2(path, os.path.join(tempdir, path))
+        shutil.copy2("../../LICENSE", os.path.join(tempdir, "LICENSE"))
+        shutil.copy2("../../README.md", os.path.join(tempdir, "README.md"))
+
+        shutil.copy2(
+            "../../tools/python_api/pyproject.toml",
+            os.path.join(tempdir, "pyproject.toml"),
+        )
+        # Update the version in pyproject.toml
+        with open(os.path.join(tempdir, "pyproject.toml"), "r") as f:
+            lines = f.readlines()
+        with open(os.path.join(tempdir, "pyproject.toml"), "w") as f:
+            for line in lines:
+                if line.startswith("version ="):
+                    f.write('version = "%s"\n' % _get_lbug_version())
+                else:
+                    f.write(line)
+        shutil.copy2("README.md", os.path.join(tempdir, "README_PYTHON_BUILD.md"))
+        subprocess.check_call([sys.executable, "setup.py", "egg_info"], cwd=tempdir)
+        shutil.copy2(
+            os.path.join(tempdir, "real_ladybug.egg-info", "PKG-INFO"),
+            os.path.join(tempdir, "PKG-INFO"),
+        )
+        with tarfile.open(file_name, "w:gz") as sdist:
+            sdist.add(tempdir, "sdist")

real_ladybug-source/scripts/pip-package/setup.py

@@ -0,0 +1,130 @@
+import shutil
+import subprocess
+import multiprocessing
+import os
+import sys
+
+from setuptools import setup, Extension
+from setuptools.command.build_ext import build_ext
+from setuptools.command.build_py import build_py as _build_py
+
+base_dir = os.path.dirname(__file__)
+
+with open(os.path.join(base_dir, 'real_ladybug-source', 'tools', 'python_api', 'requirements_dev.txt')) as f:
+    requirements = f.read().splitlines()
+
+
+def _get_lbug_version():
+    cmake_file = os.path.join(base_dir, 'real_ladybug-source', 'CMakeLists.txt')
+    with open(cmake_file) as f:
+        for line in f:
+            if line.startswith('project(Lbug VERSION'):
+                raw_version = line.split(' ')[2].strip()
+                version_nums = raw_version.split('.')
+                if len(version_nums) <= 3:
+                    return raw_version
+                else:
+                    dev_suffix = version_nums[3]
+                    version = '.'.join(version_nums[:3])
+                    version += ".dev%s" % dev_suffix
+                    return version
+
+lbug_version = _get_lbug_version()
+print("The version of this build is %s" % lbug_version)
+
+
+class CMakeExtension(Extension):
+    def __init__(self, name: str, sourcedir: str = "") -> None:
+        super().__init__(name, sources=[])
+        self.sourcedir = os.path.abspath(sourcedir)
+
+
+class CMakeBuild(build_ext):
+    def build_extension(self, ext: CMakeExtension) -> None:
+        self.announce("Building native extension...")
+        # Pass the platform architecture for arm64 to cmake for
+        # cross-compilation.
+        env_vars = os.environ.copy()
+        python_version = '.'.join(
+            (str(sys.version_info.major),  str(sys.version_info.minor)))
+        self.announce("Python version is %s" % python_version)
+        env_vars['PYBIND11_PYTHON_VERSION'] = python_version
+        env_vars['PYTHON_EXECUTABLE'] = sys.executable
+
+        if sys.platform == 'darwin':
+            archflags = os.getenv("ARCHFLAGS", "")
+
+            if len(archflags) > 0:
+                self.announce("The ARCHFLAGS is set to '%s'." %
+                              archflags)
+                if archflags == "-arch arm64":
+                    env_vars['CMAKE_OSX_ARCHITECTURES'] = "arm64"
+                elif archflags == "-arch x86_64":
+                    env_vars['CMAKE_OSX_ARCHITECTURES'] = "x86_64"
+                else:
+                    self.announce(
+                        "The ARCHFLAGS is not valid and will be ignored.")
+            else:
+                self.announce("The ARCHFLAGS is not set.")
+
+            deploy_target = os.getenv("MACOSX_DEPLOYMENT_TARGET", "")
+            if len(deploy_target) > 0:
+                self.announce("The deployment target is set to '%s'." %
+                              deploy_target)
+                env_vars['CMAKE_OSX_DEPLOYMENT_TARGET'] = deploy_target
+
+        build_dir = os.path.join(ext.sourcedir, 'real_ladybug-source')
+
+        # Clean the build directory.
+        subprocess.run(['make', 'clean'], check=True, cwd=build_dir)
+
+        try:
+            num_cores = int(os.environ['NUM_THREADS'])
+            self.announce("Using %d cores for building the native extension." % num_cores)
+        except:
+            self.announce("NUM_THREADS is not set. Using all available cores.")
+            num_cores = multiprocessing.cpu_count()
+
+        # Build the native extension.
+        full_cmd = ['make', 'python', 'NUM_THREADS=%d' % num_cores]
+        subprocess.run(full_cmd, cwd=build_dir, check=True, env=env_vars)
+        self.announce("Done building native extension.")
+        self.announce("Copying native extension...")
+        dst = os.path.join(ext.sourcedir, ext.name)
+        shutil.rmtree(dst, ignore_errors=True)
+        shutil.copytree(os.path.join(build_dir, 'tools', 'python_api', 'build',
+                                     ext.name), dst)
+        # Copy to build directory (for wheel packaging) - THIS IS CRITICAL
+        self.announce("Copying native extension to build directory...")
+        build_dst = os.path.join(self.build_lib, ext.name)
+        shutil.rmtree(build_dst, ignore_errors=True)
+        shutil.copytree(os.path.join(build_dir, 'tools', 'python_api', 'build',
+                                     ext.name), build_dst)
+
+        self.announce("Done copying native extension.")
+
+
+class BuildExtFirst(_build_py):
+    # Override the build_py command to build the extension first.
+    def run(self):
+        self.run_command("build_ext")
+        return super().run()
+
+
+setup(name='real_ladybug',
+      version=lbug_version,
+      install_requires=[],
+      ext_modules=[CMakeExtension(
+          name="real_ladybug", sourcedir=base_dir)],
+      description='An in-process property graph database management system built for query speed and scalability.',
+      license='MIT',
+      long_description=open(os.path.join(base_dir, "README.md"), 'r').read(),
+      long_description_content_type="text/markdown",
+      packages=["real_ladybug"],
+      zip_safe=True,
+      include_package_data=True,
+      cmdclass={
+          'build_py': BuildExtFirst,
+          'build_ext': CMakeBuild,
+      }
+      )

real_ladybug-source/scripts/run-clang-format.py

@@ -0,0 +1,408 @@
+#!/usr/bin/env python3
+"""A wrapper script around clang-format, suitable for linting multiple files
+and to use for continuous integration.
+
+This is an alternative API for the clang-format command line.
+It runs over multiple files and directories in parallel.
+A diff output is produced and a sensible exit code is returned.
+
+"""
+
+from __future__ import print_function, unicode_literals
+
+import argparse
+import codecs
+import difflib
+import errno
+import fnmatch
+import io
+import multiprocessing
+import os
+import signal
+import subprocess
+import sys
+import traceback
+from functools import partial
+
+try:
+    from subprocess import DEVNULL  # py3k
+except ImportError:
+    DEVNULL = open(os.devnull, "wb")
+
+DEFAULT_EXTENSIONS = 'c,h,C,H,cpp,hpp,cc,hh,c++,h++,cxx,hxx'
+DEFAULT_CLANG_FORMAT_IGNORE = '.clang-format-ignore'
+
+
+class ExitStatus:
+    SUCCESS = 0
+    DIFF = 1
+    TROUBLE = 2
+
+
+def excludes_from_file(ignore_file):
+    excludes = []
+    try:
+        with io.open(ignore_file, 'r', encoding='utf-8') as f:
+            for line in f:
+                if line.startswith('#'):
+                    # ignore comments
+                    continue
+                pattern = line.rstrip()
+                if not pattern:
+                    # allow empty lines
+                    continue
+                excludes.append(pattern)
+    except EnvironmentError as e:
+        if e.errno != errno.ENOENT:
+            raise
+    return excludes;
+
+
+def list_files(files, recursive=False, extensions=None, exclude=None):
+    if extensions is None:
+        extensions = []
+    if exclude is None:
+        exclude = []
+
+    out = []
+    for file in files:
+        if recursive and os.path.isdir(file):
+            for dirpath, dnames, fnames in os.walk(file):
+                fpaths = [os.path.join(dirpath, fname) for fname in fnames]
+                for pattern in exclude:
+                    # os.walk() supports trimming down the dnames list
+                    # by modifying it in-place,
+                    # to avoid unnecessary directory listings.
+                    dnames[:] = [
+                        x for x in dnames
+                        if
+                        not fnmatch.fnmatch(os.path.join(dirpath, x), pattern)
+                    ]
+                    fpaths = [
+                        x for x in fpaths if not fnmatch.fnmatch(x, pattern)
+                    ]
+                for f in fpaths:
+                    ext = os.path.splitext(f)[1][1:]
+                    if ext in extensions:
+                        out.append(f)
+        else:
+            out.append(file)
+    return out
+
+
+def make_diff(file, original, reformatted):
+    return list(
+        difflib.unified_diff(
+            original,
+            reformatted,
+            fromfile='{}\t(original)'.format(file),
+            tofile='{}\t(reformatted)'.format(file),
+            n=3))
+
+
+class DiffError(Exception):
+    def __init__(self, message, errs=None):
+        super(DiffError, self).__init__(message)
+        self.errs = errs or []
+
+
+class UnexpectedError(Exception):
+    def __init__(self, message, exc=None):
+        super(UnexpectedError, self).__init__(message)
+        self.formatted_traceback = traceback.format_exc()
+        self.exc = exc
+
+
+def run_clang_format_diff_wrapper(args, file):
+    try:
+        ret = run_clang_format_diff(args, file)
+        return ret
+    except DiffError:
+        raise
+    except Exception as e:
+        raise UnexpectedError('{}: {}: {}'.format(file, e.__class__.__name__,
+                                                  e), e)
+
+
+def run_clang_format_diff(args, file):
+    try:
+        with io.open(file, 'r', encoding='utf-8') as f:
+            original = f.readlines()
+    except IOError as exc:
+        raise DiffError(str(exc))
+
+    if args.in_place:
+        invocation = [args.clang_format_executable, '-i', file]
+    else:
+        invocation = [args.clang_format_executable, file]
+
+    if args.style:
+        invocation.extend(['--style', args.style])
+
+    if args.dry_run:
+        print(" ".join(invocation))
+        return [], []
+
+    # Use of utf-8 to decode the process output.
+    #
+    # Hopefully, this is the correct thing to do.
+    #
+    # It's done due to the following assumptions (which may be incorrect):
+    # - clang-format will returns the bytes read from the files as-is,
+    #   without conversion, and it is already assumed that the files use utf-8.
+    # - if the diagnostics were internationalized, they would use utf-8:
+    #   > Adding Translations to Clang
+    #   >
+    #   > Not possible yet!
+    #   > Diagnostic strings should be written in UTF-8,
+    #   > the client can translate to the relevant code page if needed.
+    #   > Each translation completely replaces the format string
+    #   > for the diagnostic.
+    #   > -- http://clang.llvm.org/docs/InternalsManual.html#internals-diag-translation
+    #
+    # It's not pretty, due to Python 2 & 3 compatibility.
+    encoding_py3 = {}
+    if sys.version_info[0] >= 3:
+        encoding_py3['encoding'] = 'utf-8'
+
+    try:
+        proc = subprocess.Popen(
+            invocation,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=True,
+            **encoding_py3)
+    except OSError as exc:
+        raise DiffError(
+            "Command '{}' failed to start: {}".format(
+                subprocess.list2cmdline(invocation), exc
+            )
+        )
+    proc_stdout = proc.stdout
+    proc_stderr = proc.stderr
+    if sys.version_info[0] < 3:
+        # make the pipes compatible with Python 3,
+        # reading lines should output unicode
+        encoding = 'utf-8'
+        proc_stdout = codecs.getreader(encoding)(proc_stdout)
+        proc_stderr = codecs.getreader(encoding)(proc_stderr)
+    # hopefully the stderr pipe won't get full and block the process
+    outs = list(proc_stdout.readlines())
+    errs = list(proc_stderr.readlines())
+    proc.wait()
+    if proc.returncode:
+        raise DiffError(
+            "Command '{}' returned non-zero exit status {}".format(
+                subprocess.list2cmdline(invocation), proc.returncode
+            ),
+            errs,
+        )
+    if args.in_place:
+        return [], errs
+    return make_diff(file, original, outs), errs
+
+
+def bold_red(s):
+    return '\x1b[1m\x1b[31m' + s + '\x1b[0m'
+
+
+def colorize(diff_lines):
+    def bold(s):
+        return '\x1b[1m' + s + '\x1b[0m'
+
+    def cyan(s):
+        return '\x1b[36m' + s + '\x1b[0m'
+
+    def green(s):
+        return '\x1b[32m' + s + '\x1b[0m'
+
+    def red(s):
+        return '\x1b[31m' + s + '\x1b[0m'
+
+    for line in diff_lines:
+        if line[:4] in ['--- ', '+++ ']:
+            yield bold(line)
+        elif line.startswith('@@ '):
+            yield cyan(line)
+        elif line.startswith('+'):
+            yield green(line)
+        elif line.startswith('-'):
+            yield red(line)
+        else:
+            yield line
+
+
+def print_diff(diff_lines, use_color):
+    if use_color:
+        diff_lines = colorize(diff_lines)
+    if sys.version_info[0] < 3:
+        sys.stdout.writelines((l.encode('utf-8') for l in diff_lines))
+    else:
+        sys.stdout.writelines(diff_lines)
+
+
+def print_trouble(prog, message, use_colors):
+    error_text = 'error:'
+    if use_colors:
+        error_text = bold_red(error_text)
+    print("{}: {} {}".format(prog, error_text, message), file=sys.stderr)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        '--clang-format-executable',
+        metavar='EXECUTABLE',
+        help='path to the clang-format executable',
+        default='clang-format-11')
+    parser.add_argument(
+        '--extensions',
+        help='comma separated list of file extensions (default: {})'.format(
+            DEFAULT_EXTENSIONS),
+        default=DEFAULT_EXTENSIONS)
+    parser.add_argument(
+        '-r',
+        '--recursive',
+        action='store_true',
+        help='run recursively over directories')
+    parser.add_argument(
+        '-d',
+        '--dry-run',
+        action='store_true',
+        help='just print the list of files')
+    parser.add_argument(
+        '-i',
+        '--in-place',
+        action='store_true',
+        help='format file instead of printing differences')
+    parser.add_argument('files', metavar='file', nargs='+')
+    parser.add_argument(
+        '-q',
+        '--quiet',
+        action='store_true',
+        help="disable output, useful for the exit code")
+    parser.add_argument(
+        '-j',
+        metavar='N',
+        type=int,
+        default=0,
+        help='run N clang-format jobs in parallel'
+             ' (default number of cpus + 1)')
+    parser.add_argument(
+        '--color',
+        default='auto',
+        choices=['auto', 'always', 'never'],
+        help='show colored diff (default: auto)')
+    parser.add_argument(
+        '-e',
+        '--exclude',
+        metavar='PATTERN',
+        action='append',
+        default=[],
+        help='exclude paths matching the given glob-like pattern(s)'
+             ' from recursive search')
+    parser.add_argument(
+        '--style',
+        help='formatting style to apply (LLVM, Google, Chromium, Mozilla, WebKit)')
+
+    args = parser.parse_args()
+
+    # use default signal handling, like diff return SIGINT value on ^C
+    # https://bugs.python.org/issue14229#msg156446
+    signal.signal(signal.SIGINT, signal.SIG_DFL)
+    try:
+        signal.SIGPIPE
+    except AttributeError:
+        # compatibility, SIGPIPE does not exist on Windows
+        pass
+    else:
+        signal.signal(signal.SIGPIPE, signal.SIG_DFL)
+
+    colored_stdout = False
+    colored_stderr = False
+    if args.color == 'always':
+        colored_stdout = True
+        colored_stderr = True
+    elif args.color == 'auto':
+        colored_stdout = sys.stdout.isatty()
+        colored_stderr = sys.stderr.isatty()
+
+    version_invocation = [args.clang_format_executable, str("--version")]
+    try:
+        subprocess.check_call(version_invocation, stdout=DEVNULL)
+    except subprocess.CalledProcessError as e:
+        print_trouble(parser.prog, str(e), use_colors=colored_stderr)
+        return ExitStatus.TROUBLE
+    except OSError as e:
+        print_trouble(
+            parser.prog,
+            "Command '{}' failed to start: {}".format(
+                subprocess.list2cmdline(version_invocation), e
+            ),
+            use_colors=colored_stderr,
+        )
+        return ExitStatus.TROUBLE
+
+    retcode = ExitStatus.SUCCESS
+
+    excludes = excludes_from_file(DEFAULT_CLANG_FORMAT_IGNORE)
+    excludes.extend(args.exclude)
+
+    files = list_files(
+        args.files,
+        recursive=args.recursive,
+        exclude=excludes,
+        extensions=args.extensions.split(','))
+
+    if not files:
+        return
+
+    njobs = args.j
+    if njobs == 0:
+        njobs = multiprocessing.cpu_count() + 1
+    njobs = min(len(files), njobs)
+
+    if njobs == 1:
+        # execute directly instead of in a pool,
+        # less overhead, simpler stacktraces
+        it = (run_clang_format_diff_wrapper(args, file) for file in files)
+        pool = None
+    else:
+        pool = multiprocessing.Pool(njobs)
+        it = pool.imap_unordered(
+            partial(run_clang_format_diff_wrapper, args), files)
+        pool.close()
+    while True:
+        try:
+            outs, errs = next(it)
+        except StopIteration:
+            break
+        except DiffError as e:
+            print_trouble(parser.prog, str(e), use_colors=colored_stderr)
+            retcode = ExitStatus.TROUBLE
+            sys.stderr.writelines(e.errs)
+        except UnexpectedError as e:
+            print_trouble(parser.prog, str(e), use_colors=colored_stderr)
+            sys.stderr.write(e.formatted_traceback)
+            retcode = ExitStatus.TROUBLE
+            # stop at the first unexpected error,
+            # something could be very wrong,
+            # don't process all files unnecessarily
+            if pool:
+                pool.terminate()
+            break
+        else:
+            sys.stderr.writelines(errs)
+            if outs == []:
+                continue
+            if not args.quiet:
+                print_diff(outs, use_color=colored_stdout)
+            if retcode == ExitStatus.SUCCESS:
+                retcode = ExitStatus.DIFF
+    if pool:
+        pool.join()
+    return retcode
+
+
+if __name__ == '__main__':
+    sys.exit(main())

real_ladybug-source/scripts/setup-extension-repo.py

@@ -0,0 +1,67 @@
+import os
+import shutil
+import sys
+import platform
+import requests
+
+def extract_extension_version() -> str:
+    import re
+    pattern = r'-DLBUG_EXTENSION_VERSION=(["\'])(.*?)\1'
+    with open('./CMakeLists.txt', 'r') as f:
+        for line in f:
+            match = re.search(pattern, line)
+            if match:
+                version = match.group(2)
+                return version
+    raise Exception("Failed to infer LBUG extension version from CMAKE file.")
+
+
+def get_os() -> str:
+    os_name = "linux"
+    if sys.platform.startswith("win32"):
+        os_name = "win"
+    elif sys.platform.startswith("darwin"):
+        os_name = "osx"
+    return os_name
+
+
+def get_arch() -> str:
+    machine = platform.machine().lower()
+    if "aarch64" in machine or "arm64" in machine:
+        return "arm64"
+    return "amd64"  # Default to amd64
+
+
+extension_repo_path = 'extension/repo'
+lbug_version = 'v' + extract_extension_version()
+arch_version = f"{get_os()}_{get_arch()}"
+shutil.rmtree(extension_repo_path, ignore_errors=True)
+os.mkdir(extension_repo_path)
+path = os.path.join(extension_repo_path, lbug_version)
+os.mkdir(path)
+path = os.path.join(path, arch_version)
+os.mkdir(path)
+
+# Create common dir
+extensions = [d for d in os.listdir('extension') if os.path.isdir(os.path.join('extension', d)) and d != 'repo']
+for extension in extensions:
+    shutil.copytree(os.path.join('extension', extension, 'build'), os.path.join(path, extension))
+
+# Download duckdb lib from official repo to local
+if get_os() != "win":
+    os.mkdir(os.path.join(path, "common"))
+    file_name = 'libduckdb'
+    if get_os() == "osx":
+        file_name += '.dylib'
+    else:
+        file_name += '.so'
+    official_repo = f"https://extension.lbugdb.com/{lbug_version}/{arch_version}/common/{file_name}"
+    response = requests.get(official_repo)
+    if response.status_code == 200:
+        with open(os.path.join(path, 'common', file_name), "wb") as f:
+            f.write(response.content)
+    else:
+        print(official_repo)
+        raise Exception("Failed to download shared duckdb library from official repo.")
+
+os.system("python3 -m RangeHTTPServer 80")