PyPI - real-ladybug - Versions diffs - 0.0.1.dev1__cp310-cp310-macosx_11_0_arm64.whl - Mend

real-ladybug 0.0.1.dev1__cp310-cp310-macosx_11_0_arm64.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of real-ladybug might be problematic. Click here for more details.

Files changed (2692) hide show

@@ -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")

@@ -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,
+      }
+      )

@@ -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())

@@ -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")