fastdb4py 0.1.0__tar.gz

fastdb4py-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 world-in-progress
+
+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 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.

fastdb4py-0.1.0/MANIFEST.in

@@ -0,0 +1,9 @@
+include fastcarto/cmake/*.cmake
+include fastcarto/CMakeLists.txt
+recursive-include fastcarto/lib *
+recursive-include fastcarto/fastdb *
+recursive-include fastcarto/make-fastdb *
+recursive-include fastcarto/dump-fastdb *
+recursive-include python *
+global-exclude *.py[cod]
+global-exclude *.so *.dylib *.dll

fastdb4py-0.1.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: fastdb4py
+Version: 0.1.0
+Summary: FastCarto database bindings
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Dynamic: license-file
+
+# fastdb (v0.0.0 WIP)
+
+A C++ local database library with cross language bindings. Aiming to be a fast, lightweight, and easy-to-use data communication solution for RPC and coupled modeling in scientific computing.
+
+Wait and hope for the best...
+
+## Building
+
+Fastdb uses CMake as its build system. Below are instructions for building the core library and cross language bindings.
+
+### Python Bindings
+
+```bash
+mkdir build
+cd build
+cmake .. -DCMAKE_BUILD_TYPE=Release -DUSE_SWIG_PYTHON=ON 
+cmake --build . --config Release --parallel
+```

fastdb4py-0.1.0/README.md

@@ -0,0 +1,18 @@
+# fastdb (v0.0.0 WIP)
+
+A C++ local database library with cross language bindings. Aiming to be a fast, lightweight, and easy-to-use data communication solution for RPC and coupled modeling in scientific computing.
+
+Wait and hope for the best...
+
+## Building
+
+Fastdb uses CMake as its build system. Below are instructions for building the core library and cross language bindings.
+
+### Python Bindings
+
+```bash
+mkdir build
+cd build
+cmake .. -DCMAKE_BUILD_TYPE=Release -DUSE_SWIG_PYTHON=ON 
+cmake --build . --config Release --parallel
+```

fastdb4py-0.1.0/fastcarto/CMakeLists.txt

@@ -0,0 +1,46 @@
+include(cmake/FastdbCMakeMinimumRequired.cmake)
+cmake_minimum_required(VERSION ${FASTDB_CMAKE_VERSION_MIN}...${FASTDB_CMAKE_VERSION_MAX})
+
+project(FastCarto)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+
+if(WIN32)
+    add_compile_options("$<$<CXX_COMPILER_ID:MSVC>:/source-charset:utf-8>")
+    add_compile_options("$<$<C_COMPILER_ID:MSVC>:/source-charset:utf-8>")
+endif()
+
+function( add_source_by_dir cur_dir return_list)
+    file(GLOB_RECURSE new_files
+        ${cur_dir}/*.c
+        ${cur_dir}/*.cpp
+        ${cur_dir}/*.cxx
+        ${cur_dir}/*.h
+        ${cur_dir}/*.hpp
+        ${cur_dir}/*.hxx
+    )
+    set(${return_list} ${new_files} PARENT_SCOPE)
+
+endfunction(add_source_by_dir)
+
+set(LIB_DIR ${CMAKE_CURRENT_SOURCE_DIR}/lib)
+set(ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+    set(is_emscripten ON)
+endif()
+
+add_subdirectory(lib)
+add_subdirectory(fastdb)
+option(BUILD_TOOLS "Build CLI tools" ON)
+
+if (NOT is_emscripten AND BUILD_TOOLS)
+    add_subdirectory(make-fastdb)
+    add_subdirectory(dump-fastdb)
+endif()
+
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY   ${CMAKE_SOURCE_DIR}/bin)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY   ${CMAKE_SOURCE_DIR}/bin)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY   ${CMAKE_SOURCE_DIR}/bin)

fastdb4py-0.1.0/fastcarto/cmake/FastdbCMakeMinimumRequired.cmake

@@ -0,0 +1,2 @@
+set(FASTDB_CMAKE_VERSION_MIN 3.16)
+set(FASTDB_CMAKE_VERSION_MAX 3.31)

fastdb4py-0.1.0/fastcarto/dump-fastdb/CMakeLists.txt

@@ -0,0 +1,26 @@
+project(dump-fastdb)
+set(PROJECT_NAME dump-fastdb)
+set(PROJECT_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -march=native -DNDEBUG")
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O3 -march=native -DNDEBUG")
+
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+include_directories(${ROOT_DIR}/fastdb/include)
+include_directories(${GDAL_INCLUDE_DIRS})
+
+add_source_by_dir(${PROJECT_DIR} SOURCES)
+
+
+add_executable(${PROJECT_NAME}   ${SOURCES} )
+
+target_link_libraries(${PROJECT_NAME} fastdb)
+
+#message(STATUS ${GDAL_INCLUDE_DIRS})
+#message(STATUS ${GDAL_LIBRARIES})
+
+
+
+
+

fastdb4py-0.1.0/fastcarto/dump-fastdb/dump-fastdb-ex.cpp

@@ -0,0 +1,95 @@
+#include "fastdb.h"
+using namespace wx;
+
+const char* get_field_type_name(int ft)
+{   
+    switch(ft)
+    {
+    case ftF32:
+        return "F32";
+    case ftF64:
+        return "F64";
+    case ftI32:
+        return "I32";
+    case ftSTR:
+        return "STR";
+    case ftU16:
+        return "U16";
+    case ftU16n:
+        return "U16n";
+    case ftU32:
+        return "U32";
+    case ftU8:
+        return "U8";
+    case ftU8n:
+        return "U8n";
+    case ftREF:
+        return "REF";    
+    } 
+    return "UNKNOWN";
+}
+
+const char* get_geometry_type_name(int gt)
+{
+    switch(gt)
+    {
+    case gtAny:
+        return "Any";
+    case gtLineString:
+        return "LineString";
+    case gtPoint:
+        return "Point";
+    case gtPolygon:
+        return "Polygon";
+    case gtNone:
+        return "None";
+    }
+    return "UNKNOWN";
+}
+
+int main(int argc,char** argv) {
+    printf("\n\
+****************************************************\n\
+            fastdb dumpping utility\n\
+****************************************************\n");
+
+    FastVectorDb* db = FastVectorDb::load(argv[1]);
+    if (db) {
+        for(int ix=0;ix<db->getLayerCount();ix++)
+        {
+            FastVectorDbLayer* layer = db->getLayer(ix);
+            //枚举图层信息
+            printf("\nLayer[%d]:%s geometry type:%s\n",ix,layer->name(),get_geometry_type_name(layer->getGeometryType()));
+            double minx,miny,maxx,maxy;
+            layer->getExtent(minx,miny,maxx,maxy);
+            printf("\textent:(%lf,%lf,%lf,%lf)\n",minx,miny,maxx,maxy);
+            int fc = layer->getFeatureCount();
+            printf("\tfeature count:%d\n",fc);
+            for(int fi=0;fi<layer->getFieldCount();fi++)
+            {
+                const char* name;
+                FieldTypeEnum ft;
+                double vmin,vmax;
+                name = layer->getFieldDefn(fi,ft,vmin,vmax);
+                printf("\tField[%d]:%s type:%s range(%lf,%lf)\n",fi,name,get_field_type_name(ft),vmin,vmax);
+            }
+
+            layer->rewind();
+            printf("\tvalidate geometry.");
+            int irec=0;
+            while(layer->next())
+            { 
+                if(irec%100==0)
+                    printf(".%d.",irec);
+                irec++;
+            }
+            printf("...done!\n\tfeature count:%d\n",irec);
+        }
+        delete db;
+    }
+    else
+    {
+        printf("Can't open %s\n",argv[1]);
+    }
+    fflush(stdout);
+}

fastdb4py-0.1.0/fastcarto/fastdb/CMakeLists.txt

@@ -0,0 +1,135 @@
+project(fastdb)
+set(PROJECT_NAME fastdb)
+set(PROJECT_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+option(USE_SWIG_PYTHON "use swig python wrapper" OFF)
+option(USE_SWIG_NODE   "use swig node wrapper" OFF)
+
+add_definitions(-DFASTDB_EXPORT)
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/src)
+include_directories(${LIB_DIR}/gaiageo/headers)
+include_directories(${LIB_DIR}/gaiageo/headers/spatialite)
+include_directories(${LIB_DIR}/clipper/Clipper2Lib/include)
+include_directories(${LIB_DIR}/clipper/Clipper2Lib/include/clipper2)
+
+add_source_by_dir(${PROJECT_DIR} SOURCES)
+
+file(GLOB_RECURSE EXCLUED_FILES ${PROJECT_DIR}/swig/*.*)
+list(REMOVE_ITEM SOURCES ${EXCLUED_FILES})
+
+if(is_emscripten)
+    set(BUILD_TYPE STATIC)
+else()
+    set(BUILD_TYPE SHARED)
+endif(is_emscripten)
+
+add_library(${PROJECT_NAME} SHARED ${SOURCES})
+target_link_libraries(${PROJECT_NAME} PRIVATE gaiageo Clipper2)
+
+get_target_property(swig_out_dir ${PROJECT_NAME} SWIG_OUTPUT_DIR)
+
+set(swig_dir   ${PROJECT_DIR}/swig)
+set(script_dir ${ROOT_DIR}/scripts)
+
+if (NOT is_emscripten)
+    if(USE_SWIG_PYTHON)
+        set(script_dir ${ROOT_DIR}/../python/fastdb/core)
+        set(SWIG_GENERATED_DIR ${CMAKE_BINARY_DIR}/swig_generated)
+
+        # Copy SWIG generated files to the build directory
+        add_custom_command(
+            OUTPUT ${SWIG_GENERATED_DIR}/fastdb4py_wrap.cxx 
+                ${SWIG_GENERATED_DIR}/fastdb4py.py
+            COMMAND ${CMAKE_COMMAND} -E make_directory ${SWIG_GENERATED_DIR}
+            COMMAND swig -c++ -python 
+                    -I${PROJECT_DIR}/include
+                    -I${PROJECT_DIR}/swig
+                    -outdir ${SWIG_GENERATED_DIR}
+                    -o ${SWIG_GENERATED_DIR}/fastdb4py_wrap.cxx
+                    ${PROJECT_DIR}/swig/fastdb4py.i
+            DEPENDS ${PROJECT_DIR}/swig/fastdb4py.i
+                    ${PROJECT_DIR}/include/fastdb.h
+                    ${PROJECT_DIR}/include/fastdb-geometry-utils.h
+            COMMENT "Generating SWIG Python bindings"
+        )
+
+        set(Python3_FIND_VIRTUALENV FIRST)
+        find_package(Python3 ${PYTHON_VERSION_STRING}  COMPONENTS Interpreter  Development NumPy)
+        include_directories(${Python3_INCLUDE_DIRS} )
+        include_directories(${Python3_NumPy_INCLUDE_DIRS} )
+        message(STATUS "building fastdb with swig python wrapper support!")
+        message(STATUS numpy_dir=${Python3_NumPy_INCLUDE_DIRS})
+        message(STATUS python_libs=${Python3_LIBRARY_DIRS})
+        add_definitions(-DUSE_SWIG_PYTHON -DSWIG_PYTHON_INTERPRETER_NO_DEBUG)
+
+        add_library(fastdb4py SHARED ${SWIG_GENERATED_DIR}/fastdb4py_wrap.cxx)
+        target_link_libraries(fastdb4py PRIVATE ${PROJECT_NAME})
+        target_link_directories(fastdb4py PRIVATE ${Python3_LIBRARY_DIRS})
+
+        target_link_options(fastdb4py
+            PUBLIC
+                $<$<BOOL:${APPLE}>:-undefineddynamic_lookup>)
+        if(WIN32)
+            set(pyd pyd)
+        else()
+            set(pyd so)
+        endif(WIN32)
+        
+        add_custom_command(TARGET fastdb4py POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:fastdb4py>  ${script_dir}/_fastdb4py.${pyd}
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:${PROJECT_NAME}>  ${script_dir}/$<TARGET_FILE_NAME:${PROJECT_NAME}>
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different ${SWIG_GENERATED_DIR}/fastdb4py.py  ${script_dir}/__init__.py
+            COMMENT "updating fastdb4py into scripts directory"
+        )
+
+    else()
+        message(STATUS "if you want swig python support please check USE_SWIG_PYTHON!")
+    endif(USE_SWIG_PYTHON)
+
+    if(USE_SWIG_NODE)
+        include_directories(${ROOT_DIR}/node_modules/node-addon-api)
+        include_directories(${ROOT_DIR}/node_modules/node-api-headers/include/)
+        add_library(fastdb4node SHARED ${PROJECT_DIR}/swig/fastdb4node.cxx)
+        target_link_libraries(fastdb4node PRIVATE ${PROJECT_NAME})
+
+        target_link_options(fastdb4node
+            PUBLIC
+                $<$<BOOL:${APPLE}>:-undefineddynamic_lookup>)
+        
+        if(WIN32)
+            target_link_libraries(fastdb4node PRIVATE ${ROOT_DIR}/node_modules/node-api-headers/lib/node_api.lib)
+            target_link_libraries(fastdb4node PRIVATE ${ROOT_DIR}/node_modules/node-api-headers/lib/js_native_api.lib)
+        endif()
+
+
+        add_custom_command(TARGET fastdb4node POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:fastdb4node>  ${script_dir}/_fastdb.node
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:${PROJECT_NAME}>  ${script_dir}/$<TARGET_FILE_NAME:${PROJECT_NAME}>
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different ${swig_dir}/fastdb.js  ${script_dir}/fastdb.js
+            
+            COMMENT "updating fastdb4node into swig directory"
+        )
+    endif(USE_SWIG_NODE)
+else()
+    message(STATUS "linking swig wrapper...") 
+     add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
+     COMMAND emcc 
+            "-O2" 
+            "-s" "WASM=0" 
+            #"-s" "MODULARIZE=1" 
+            #"-s" EXPORT_NAME="'fastdb'"
+            #"-s" 'EXTRA_EXPORTED_RUNTIME_METHODS=["cwrap","_free","_malloc"]'
+            "-s" "ALLOW_MEMORY_GROWTH=1" 
+            "-s" "INITIAL_MEMORY=16777216" 
+            "-s" "TOTAL_MEMORY=16777216" 
+            "-s" "TOTAL_STACK=5242880" 
+            "-s" "ERROR_ON_UNDEFINED_SYMBOLS=0" 
+            "--post-js" "${swig_dir}/fastdb4em_i.js" 
+            "-I" ${CMAKE_CURRENT_SOURCE_DIR}/include
+            "$<TARGET_FILE:${PROJECT_NAME}>"    "${swig_dir}/fastdb4em.cxx"
+            "-o" "${script_dir}/fastdb4em.js"
+     COMMENT "emcc linking fastdb.js"
+     )
+endif()

fastdb4py-0.1.0/fastcarto/fastdb/include/fastdb-config.h

@@ -0,0 +1,32 @@
+#pragma once
+//FastVectorDB:A fast vector database for local cache
+//Author: wenyongning@njnu.edu.cn
+#include <stdlib.h>
+#include <stdio.h>
+#include <cstring>
+namespace wx{
+    typedef          char   i8;
+    typedef unsigned char   u8;
+    typedef unsigned int    i32;
+    typedef unsigned int    u32;
+    typedef          short  i16;
+    typedef unsigned short  u16;
+    typedef float           f32;
+    typedef double          f64;
+    typedef u16             uchar_t;
+}
+
+#ifdef SWIG
+    #define fastdb_api
+#else
+    #ifdef _WIN32
+        #ifdef FASTDB_EXPORT
+            #define fastdb_api __declspec(dllexport)
+        #else
+            #define fastdb_api __declspec(dllimport)
+        #endif
+    #else
+        #define fastdb_api __attribute__((visibility("default")))
+    #endif
+#endif
+

fastdb4py-0.1.0/fastcarto/fastdb/include/fastdb-geometry-utils.h

@@ -0,0 +1,175 @@
+#pragma once
+#include <vector>
+#include <string>
+#include "fastdb.h"
+using namespace std;
+
+#ifndef WIN32
+#include <cmath>
+#endif
+
+namespace wx
+{
+    class GeometryUtils : public GeometryReturn
+    {
+    public:
+        double minx;
+        double miny;
+        double maxx;
+        double maxy;
+        GeometryLikeEnum gtype;
+        point2_t point;
+        std::vector<point2_t> points;
+        std::vector<int> part_length;
+        std::vector<size_t> part_first_point;
+        std::vector<GeometryPartEnum> part_type;
+        std::vector<int> polygon_part_count;
+        std::vector<int> polygon_first_part;
+
+    public:
+        inline int get_point_count()
+        {
+            return points.size();
+        }
+
+        template <class pointT = point2_t>
+        inline const pointT *point_data(int ix = 0)
+        {
+            if (sizeof(pointT) == sizeof(point2_t))
+                return (const pointT *)points.data() + get_part_first_point(ix);
+            else
+                return NULL;
+        }
+        inline const int *part_data()
+        {
+            return part_length.data();
+        }
+
+        inline int get_part_count()
+        {
+            return part_length.size();
+        }
+        inline int get_part_length(int ix)
+        {
+            return part_length[ix];
+        }
+
+        inline const point2_t &get_point_at(int ix)
+        {
+            return points[ix];
+        }
+
+        inline int get_part_first_point(int ix)
+        {
+            return part_first_point[ix];
+        }
+
+        inline int get_polygon_part_count(int ix)
+        {
+            return polygon_part_count[ix];
+        }
+
+        inline int get_polygon_count()
+        {
+            return polygon_part_count.size();
+        }
+
+        inline int get_polygon_first_part(int ix)
+        {
+            return polygon_first_part[ix];
+        }
+
+        inline int np()
+        {
+            return points.size();
+        }
+
+    public:
+        template <typename pprocT>
+        void post_process_points(pprocT proc)
+        {
+            if (points.size())
+                for (auto &p : points)
+                    proc(p);
+            else
+            {
+                proc(point);
+            }
+        }
+        void udpate_bounding_box()
+        {
+            minx = points[0].x;
+            miny = points[0].y;
+            maxx = points[0].x;
+            maxy = points[0].y;
+
+            for (int i = 1, np = points.size(); i < np; i++)
+            {
+                if (points[i].x < minx)
+                    minx = points[i].x;
+                if (points[i].x > maxx)
+                    maxx = points[i].x;
+                if (points[i].y < miny)
+                    miny = points[i].y;
+                if (points[i].y > maxy)
+                    maxy = points[i].y;
+            }
+        }
+
+    public:
+        virtual bool begin(const double aabbox[4])
+        {
+            if (aabbox)
+            {
+                minx = aabbox[0];
+                miny = aabbox[1];
+                maxx = aabbox[2];
+                maxy = aabbox[3];
+            }
+            else
+            {
+                minx = miny = maxx = maxy = NAN;
+            }
+            points.clear();
+            part_length.clear();
+            part_type.clear();
+            part_first_point.clear();
+            polygon_first_part.clear();
+            polygon_part_count.clear();
+
+            return true;
+        }
+        virtual void returnGeomrtryPart(GeometryPartEnum partType, point2_t *pts, int np)
+        {
+            if (partType == gptPoint2)
+            {
+                gtype = gtPoint;
+                point = pts[0];
+            }
+            else if (partType == gptLineString)
+            {
+                gtype = gtLineString;
+            }
+            else if (partType == gptRingExternal)
+            {
+                gtype = gtPolygon;
+                polygon_first_part.push_back(part_length.size());
+                polygon_part_count.push_back(1);
+            }
+            else if (partType == gptRingInternal)
+            {
+                polygon_part_count.back() += 1;
+            }
+            if (gtype != gtPoint)
+            {
+                part_first_point.push_back(points.size());
+                part_length.push_back(np);
+                part_type.push_back(partType);
+                points.insert(points.end(), pts, pts + np);
+            }
+        }
+        virtual void end()
+        {
+        }
+    };
+}