liburlparser 2.0.0__tar.gz → 2.2.0__tar.gz

{liburlparser-2.0.0 → liburlparser-2.2.0}/.github/workflows/orchestrator.yml

@@ -99,6 +99,9 @@ jobs:
       id-token: write
 
     steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
     - name: Download documentation artifact
       uses: actions/download-artifact@v4
       with:
@@ -111,6 +114,18 @@ jobs:
         name: cmake-coverage-report
         path: ./pages/coverage
 
+    # Benchmarks are NOT run in CI: the report is generated locally
+    # (cmake --build <dir> --target urlparser_benchmarks_report) and committed
+    # as benchmarks/results/report.html. CI only publishes it, as /benchmarks/.
+    - name: Add benchmark report
+      run: |
+        if [ ! -f benchmarks/results/report.html ]; then
+          echo "::error::benchmarks/results/report.html is missing - generate it locally and commit it"
+          exit 1
+        fi
+        mkdir -p pages/benchmarks
+        cp benchmarks/results/report.html pages/benchmarks/index.html
+
     - name: List pages directory
       run: find pages -maxdepth 2
 

{liburlparser-2.0.0 → liburlparser-2.2.0}/.github/workflows/wheels.yml

@@ -53,7 +53,7 @@ jobs:
     - uses: actions/checkout@v4
 
     - name: Build wheels
-      uses: pypa/cibuildwheel@v2.21.3
+      uses: pypa/cibuildwheel@v4.2.1
       env:
         MACOSX_DEPLOYMENT_TARGET: "10.13"
         CIBW_ARCHS_MACOS: universal2

liburlparser-2.2.0/CHANGELOG.md

@@ -0,0 +1,212 @@
+# Changelog
+
+All notable changes to liburlparser are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project follows
+[Semantic Versioning](https://semver.org/). The version of the project is the one in `include/urlparser.h`
+(`URLPARSER_VERSION_MAJOR/MINOR/PATCH`); `pyproject.toml` and CMake read it from there.
+
+The entries up to 2.1.0 were written from the git history and the release tags. Since the commit messages of the 1.x
+releases are short, those entries are brief.
+
+## [2.2.0] - 2026-11-09
+
+### Changed
+- **The CMake package namespace is now `liburlparser::`, like the package.** The public target is
+  `liburlparser::urlparser`, the same name from `add_subdirectory()`, `FetchContent` and
+  `find_package(liburlparser CONFIG)`. A CMake package should export its targets under its own name, and the
+  package is `liburlparser` (`liburlparserConfig.cmake`, `python -m liburlparser --cmake-dir`). **Breaking:** the
+  2.1.0 name `urlparser::urlparser` is gone and there is no alias for it. Change `target_link_libraries(... urlparser::urlparser)` to
+  `liburlparser::urlparser`. The C++ namespace (`urlparser::url`, `urlparser::host`) is unchanged.
+- The `example` program is built only when liburlparser is the top-level project, like the tests and the docs, so it is
+  not compiled for nothing when the library is a dependency.
+
+### Fixed
+- **Using liburlparser from another scikit-build-core project failed.** `SKBUILD` is defined for the whole build, so a
+  project that pulled liburlparser in with `add_subdirectory()` or `FetchContent` made it believe it was itself the wheel
+  being built: it tried to build its own nanobind module (and failed when nanobind was not installed) or stopped
+  with `RETURN()` before the example, tests and docs. The check is now "`SKBUILD` is defined **and** liburlparser is the
+  top-level project". The 2.0.0 release had a guard for this (`c140ea4`); the CMake refactor of 2.1.0 (`ac6ac03`)
+  dropped it.
+
+## [2.1.0] - 2026-10-03
+
+### Added
+- **`find_package(liburlparser CONFIG)`.** The core is a static library that is installed with its headers and a CMake
+  package (`liburlparserConfig.cmake`, targets, version file, and `liburlparserPaths.cmake` with the absolute library
+  and include paths). The Python wheel carries the same tree (`include/`, `lib/`, `cmake/`), and
+  `python -m liburlparser --cmake-dir` / `--include-dir` / `--lib-dir` print the paths, the way `python -m nanobind --cmake_dir` does.
+  `examples/find_liburlparser_via_python` shows it.
+- **IDNA normalization and percent codec APIs.**
+- **scp-like git URLs** (`user@host:path/repo.git`) are parsed.
+- **`url::normalized()`** returns a canonical serialization of a URL.
+- Benchmarks: `search_params` against ada, a reproducible comparison of the PSL structures, benchmark artifacts kept apart
+  from the committed results, and an HTML report target.
+
+### Changed
+- **The CMake targets are unified.** The historical aliases `url::base` and `liburlparser::core` are replaced by the one
+  public alias `urlparser::urlparser`, and `install(EXPORT)` uses the same name. (**Breaking** for anyone who linked the old aliases;
+  renamed again in 2.2.0.)
+- The standalone `idna.cpp` and `percent_codec.cpp` are merged into `urlparser.cpp`, and stale files left from the
+  header/source consolidation were removed.
+- The bundled `public_suffix_list.dat` is the 2026-09-08 version.
+- CI: cibuildwheel is updated.
+
+### Performance
+- AVX2 scanning for the authority of a URL.
+- PSL suffix matching tracks the maximum rule depth, and the truncation scan in `suffix_of` and the TLD suffix are bounded
+  by the maximum length (an O(1) check instead of an O(n) scan).
+- A fast path with interned keys when a `Hostname` is extracted to a Python dict.
+
+## [2.0.0] - 2026-09-11
+
+### Added
+- **Public Suffix List support.** A `psl` class (a singleton that tracks the version of its data) matches suffixes; the
+  list is embedded into the library when CMake configures, and a configure step refreshes the tracked
+  `public_suffix_list.dat` in place when it can download a newer one.
+- **`host`** parsing and classification, with constructor overloads and `string&&` overloads of `host::from_url` and
+  `url::extract_host`. Cross-platform IP address parsing replaces the platform-specific code.
+- **Version macros** `URLPARSER_VERSION_*` and a version class (the prefix was renamed from `LIBURLPARSER_`); CMake reads the version from the
+  header.
+- SIMD scanning in `find_first_of_3` (AVX2, SSE2, NEON).
+- Python: a static `Url.extract_dict`, built from reusable `to_dict` helpers.
+- Tooling: coverage reports for C++ and Python, leak checks with pytest-memray, benchmark and profiling targets, standalone
+  benchmarks (also against ada), Sphinx documentation for the Python API, a CLI reference, and architecture notes.
+
+### Changed
+- **liburlparser is a static library**, built with position-independent code, and the default build type is Release.
+- nanobind ABI handling for Python 3.12 and later.
+- The googletest and doxygen-awesome-css submodules are removed, and the `online` extra is gone (the PSL update uses `urllib`).
+- Tests and docs are built only when liburlparser is the top-level project, and a vendored copy does not build its Python
+  bindings.
+- The implementation of the suffix table is hidden behind a forward declaration.
+
+### Fixed
+- Windows compatibility (pull request #4, by CKCat).
+- Regression tests for earlier URL parsing bugs.
+
+### Performance
+- Extra capacity for URL fields, a faster `host` constructor, and the suffix position is computed by arithmetic.
+
+## [1.6.1] - 2025-10-24
+
+### Changed
+- The CLI logic is refactored and covered by tests, and `flatten_dict` moved to the utils module.
+- The release workflow and the wheel builds are improved (`test_cli_subprocess` is excluded in CI).
+
+## [1.6.0] - 2025-05-04
+
+### Added
+- `--parts` option of the command line, and the top-level domain (TLD) of a host.
+- The Public Suffix List file.
+- Doxygen documentation (main page with logo and architecture diagram, doxygen-awesome theme) and the Python documentation,
+  published to GitHub Pages.
+
+## [1.5.0] - 2024-10-18
+
+### Changed
+- The project architecture changed, and the CI runs all tests (C++ and Python).
+- Build requirements are managed with pip-tools; ruff fixes.
+
+## [1.4.6] - 2024-02-11
+
+### Changed
+- macOS is built in CI, the build system changed, and the README got badges.
+
+## [1.4.5] - 2023-11-28
+
+### Changed
+- The Doxygen project information is read from `pyproject.toml`, and the release workflow uploads the release assets.
+
+## [1.4.4] - 2023-11-23
+
+### Changed
+- The C++ tests moved to googletest and were rewritten as parametrized tests, like the Python ones; C++ and Python
+  tests are separate. The wheel files are created.
+
+## [1.4.3] - 2023-11-19
+
+### Fixed
+- A file lock lets the tests run in parallel.
+
+## [1.4.2] - 2023-11-13
+
+### Changed
+- `shared_ptr` replaces `unique_ptr`, since every method is const.
+
+### Fixed
+- The `fulldomain` problem, and the host name was removed again.
+
+## [1.4.1] - 2023-11-11
+
+### Added
+- C++ tests with gtest and gmock.
+- A fast `hostName` that does not parse the host string (with a known problem with `ignore_www`).
+
+### Changed
+- The PSL is held as data instead of a pointer (fixes the pointer-to-data conversion), and `requests` became an optional
+  dependency (the `online` extra).
+
+## [1.4.0] - 2023-11-08
+
+### Changed
+- `urlparser.cpp` is split into a host part and a url part, a url holds its host through a pointer, and the lazy
+  calculation uses a smart pointer.
+
+### Fixed
+- Problems with the operators; the move constructor and assignment were removed.
+
+## [1.3.0] - 2023-11-05
+
+### Fixed
+- `fulldomain` in the substring step; accessibility of the class; test and linter issues. An automatic correction was
+  tried and removed.
+
+## [1.2.1] - 2023-10-10
+
+### Fixed
+- The `fulldomain` issue.
+
+## [1.2.0] - 2023-10-09
+
+### Changed
+- The `fulldomain` attribute was updated.
+
+## [1.1.0] - 2023-07-23
+
+### Added
+- The `ignore_www` option for subdomains.
+
+## [1.0.2] - 2023-07-22
+
+### Added
+- A Ruff lint check.
+
+## [1.0.1] - 2023-07-21
+
+### Fixed
+- `pyproject.toml` and the wheels workflow.
+
+## [1.0.0] - 2023-07-21
+
+First tagged release. The history before it is mostly the setup of the wheel builds with cibuildwheel (PyPy excluded).
+
+[2.2.0]: https://github.com/mohammadraziei/liburlparser/compare/v2.1.0...v2.2.0
+[2.1.0]: https://github.com/mohammadraziei/liburlparser/compare/v2.0.0...v2.1.0
+[2.0.0]: https://github.com/mohammadraziei/liburlparser/compare/v1.6.1...v2.0.0
+[1.6.1]: https://github.com/mohammadraziei/liburlparser/compare/v1.6.0...v1.6.1
+[1.6.0]: https://github.com/mohammadraziei/liburlparser/compare/v1.5.0...v1.6.0
+[1.5.0]: https://github.com/mohammadraziei/liburlparser/compare/v1.4.6...v1.5.0
+[1.4.6]: https://github.com/mohammadraziei/liburlparser/compare/v1.4.5...v1.4.6
+[1.4.5]: https://github.com/mohammadraziei/liburlparser/compare/v1.4.4...v1.4.5
+[1.4.4]: https://github.com/mohammadraziei/liburlparser/compare/v1.4.3...v1.4.4
+[1.4.3]: https://github.com/mohammadraziei/liburlparser/compare/v1.4.2...v1.4.3
+[1.4.2]: https://github.com/mohammadraziei/liburlparser/compare/v1.4.1...v1.4.2
+[1.4.1]: https://github.com/mohammadraziei/liburlparser/compare/v1.4.0...v1.4.1
+[1.4.0]: https://github.com/mohammadraziei/liburlparser/compare/v1.3.0...v1.4.0
+[1.3.0]: https://github.com/mohammadraziei/liburlparser/compare/v1.2.1...v1.3.0
+[1.2.1]: https://github.com/mohammadraziei/liburlparser/compare/v1.2.0...v1.2.1
+[1.2.0]: https://github.com/mohammadraziei/liburlparser/compare/v1.1.0...v1.2.0
+[1.1.0]: https://github.com/mohammadraziei/liburlparser/compare/v1.0.2...v1.1.0
+[1.0.2]: https://github.com/mohammadraziei/liburlparser/compare/v1.0.1...v1.0.2
+[1.0.1]: https://github.com/mohammadraziei/liburlparser/compare/v1.0.0...v1.0.1
+[1.0.0]: https://github.com/mohammadraziei/liburlparser/releases/tag/v1.0.0

{liburlparser-2.0.0 → liburlparser-2.2.0}/CMakeLists.txt

@@ -38,17 +38,20 @@ if (CYGWIN OR UNIX)
 endif()
 
 
+# URLPARSER_SKBUILD is true only when liburlparser itself is the scikit-build-core
+# project being built (the wheel build). SKBUILD alone is not enough: it is also
+# defined when another scikit-build-core project (e.g. httpp) pulls this one in with
+# add_subdirectory() or FetchContent, and then it must behave as a plain C++ library:
+# no nanobind module, no early RETURN() before the liburlparser::urlparser target and the tests.
+if(DEFINED SKBUILD AND CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+    set(URLPARSER_SKBUILD ON)
+else()
+    set(URLPARSER_SKBUILD OFF)
+endif()
+
 find_package(Python3 REQUIRED COMPONENTS Interpreter)
 
-# --- httpp local patch --------------------------------------------------
-# Only treat this as "liburlparser is the scikit-build-core package being
-# installed" when SKBUILD_PROJECT_NAME actually IS liburlparser. Without
-# this guard, vendoring liburlparser as a subdirectory of another
-# scikit-build-core project (e.g. httpp) makes it wrongly think it's the
-# top-level package and try to build its own nanobind bindings, which
-# fails when nanobind isn't installed (it isn't a dependency of the
-# parent project at all). See src/third_party/README.md for details.
-if(DEFINED SKBUILD AND SKBUILD_PROJECT_NAME STREQUAL PROJECT_NAME)
+if(URLPARSER_SKBUILD)
     set(PYTHON_PROJECT_NAME "${SKBUILD_PROJECT_NAME}")
 elseif(BUILD_PYTHON)
     set(PYTHON_PROJECT_NAME "${CMAKE_BINARY_DIR}")
@@ -104,6 +107,44 @@ embed_file_as_string(
 )
 
 
+# --- C++ core library (static) ---
+# Built in every mode (including scikit-build), so the Python extension
+# links the very same library that gets shipped to C++ consumers.
+# Install layout: the wheel carries include/, lib/ and cmake/ inside the
+# `liburlparser` package (nanobind/pybind11 pattern, see get_cmake_dir() in
+# the Python package); a plain `cmake --install` uses the usual prefix layout.
+if(URLPARSER_SKBUILD)
+    set(_urlparser_lib_dest   liburlparser/lib)
+    set(_urlparser_inc_dest   liburlparser/include)
+    set(_urlparser_cmake_dest liburlparser/cmake)
+else()
+    set(_urlparser_lib_dest   lib)
+    set(_urlparser_inc_dest   include)
+    set(_urlparser_cmake_dest lib/cmake/liburlparser)
+endif()
+
+add_library(urlparser STATIC ${SOURCES})
+# The public target is `liburlparser::urlparser` - the same name whether the
+# library comes from FetchContent/add_subdirectory (this alias) or from an
+# installed package (find_package(liburlparser), exported below).
+add_library(liburlparser::urlparser ALIAS urlparser)
+
+set_target_properties(urlparser PROPERTIES
+    POSITION_INDEPENDENT_CODE ON        # linked into the Python extension
+    CXX_VISIBILITY_PRESET hidden
+    VISIBILITY_INLINES_HIDDEN ON
+    EXPORT_NAME urlparser               # installed as liburlparser::urlparser (see install(EXPORT))
+    OUTPUT_NAME urlparser               # liburlparser.a / urlparser.lib
+)
+target_include_directories(urlparser
+    PUBLIC
+        $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:${_urlparser_inc_dest}>
+    PRIVATE
+        ${PROJECT_SOURCE_DIR}/src
+        ${GENERATED_HEADERS_DIR})
+
+
 if(DEFINED PYTHON_PROJECT_NAME)
     # Try to import all Python components potentially needed by nanobind
     #set(Python3_FIND_STRATEGY LOCATION)
@@ -140,12 +181,12 @@ if(DEFINED PYTHON_PROJECT_NAME)
             ${NB_ABI_ARGS}
 
             # Source code goes here
-            ${PROJECT_SOURCE_DIR}/src/bindings/python/binding_py.cpp ${SOURCES}
+            ${PROJECT_SOURCE_DIR}/src/bindings/python/binding_py.cpp
     )
 
-    target_include_directories(${NB_MODULE} PRIVATE include src ${GENERATED_HEADERS_DIR})
+    target_link_libraries(${NB_MODULE} PRIVATE urlparser)
 
-    if(DEFINED SKBUILD)
+    if(URLPARSER_SKBUILD)
         install(TARGETS ${NB_MODULE}
                 CONFIGURATIONS Release
                 LIBRARY DESTINATION
@@ -157,37 +198,56 @@ if(DEFINED PYTHON_PROJECT_NAME)
     endif()
 endif()
 
-if(DEFINED SKBUILD AND SKBUILD_PROJECT_NAME STREQUAL PROJECT_NAME)
-    # (see the httpp local-patch comment above) only early-return here when
-    # liburlparser itself is the package scikit-build-core is installing —
-    # not when it's vendored as a subdirectory of another project.
+# --- install: find_package(liburlparser CONFIG) -> liburlparser::urlparser ---
+include(CMakePackageConfigHelpers)
+install(TARGETS urlparser EXPORT liburlparserTargets
+    ARCHIVE DESTINATION ${_urlparser_lib_dest}
+    LIBRARY DESTINATION ${_urlparser_lib_dest})
+install(DIRECTORY include/ DESTINATION ${_urlparser_inc_dest})
+install(EXPORT liburlparserTargets
+    FILE liburlparserTargets.cmake
+    NAMESPACE liburlparser::
+    DESTINATION ${_urlparser_cmake_dest})
+
+# urlparser_LIB_PATH / urlparser_INCLUDE_PATH for consumers that want plain
+# paths. The exact artifact name (liburlparser.a, urlparser.lib, ...) is only
+# known to the generator, so the file is produced with file(GENERATE) - the
+# generator expression is resolved when the build system is generated, and the
+# result is installed next to the package config. Paths are written relative
+# to the installed file itself, so the package stays relocatable.
+file(RELATIVE_PATH _urlparser_rel_lib "/_/${_urlparser_cmake_dest}" "/_/${_urlparser_lib_dest}")
+file(RELATIVE_PATH _urlparser_rel_inc "/_/${_urlparser_cmake_dest}" "/_/${_urlparser_inc_dest}")
+string(REGEX REPLACE "/+$" "" _urlparser_rel_lib "${_urlparser_rel_lib}")
+string(REGEX REPLACE "/+$" "" _urlparser_rel_inc "${_urlparser_rel_inc}")
+file(GENERATE
+    OUTPUT ${PROJECT_BINARY_DIR}/liburlparserPaths.cmake
+    CONTENT
+"# Generated by liburlparser's CMakeLists.txt - do not edit.
+get_filename_component(urlparser_LIB_PATH
+    \"\${CMAKE_CURRENT_LIST_DIR}/${_urlparser_rel_lib}/$<TARGET_FILE_NAME:urlparser>\" ABSOLUTE)
+get_filename_component(urlparser_INCLUDE_PATH
+    \"\${CMAKE_CURRENT_LIST_DIR}/${_urlparser_rel_inc}\" ABSOLUTE)
+")
+
+write_basic_package_version_file(
+    ${PROJECT_BINARY_DIR}/liburlparserConfigVersion.cmake
+    VERSION ${PROJECT_VERSION}
+    COMPATIBILITY SameMajorVersion)
+install(FILES
+    ${PROJECT_SOURCE_DIR}/cmake/liburlparserConfig.cmake
+    ${PROJECT_BINARY_DIR}/liburlparserPaths.cmake
+    ${PROJECT_BINARY_DIR}/liburlparserConfigVersion.cmake
+    DESTINATION ${_urlparser_cmake_dest})
+
+if(URLPARSER_SKBUILD)
     RETURN()
 endif()
 
-
-
-add_library(urlparser STATIC ${SOURCES})
-add_library(url::base ALIAS urlparser)
-target_include_directories(urlparser PRIVATE ${GENERATED_HEADERS_DIR})
-
-
-target_include_directories(urlparser
-        PUBLIC
-            ${PROJECT_SOURCE_DIR}/include
-        PRIVATE
-            ${PROJECT_SOURCE_DIR}/src)
-
-
-add_executable(example examples/main.cpp)
-target_link_libraries(example PRIVATE url::base)
-
-install(TARGETS urlparser
-    LIBRARY DESTINATION lib
-    ARCHIVE DESTINATION lib
-    INCLUDES DESTINATION include
-)
-
-
+# The example is only for the top-level build; as a dependency it would just be compiled for nothing.
+if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+    add_executable(example examples/main.cpp)
+    target_link_libraries(example PRIVATE liburlparser::urlparser)
+endif()
 
 enable_testing()
 find_package(Threads REQUIRED)

{liburlparser-2.0.0 → liburlparser-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: liburlparser
-Version: 2.0.0
+Version: 2.2.0
 Summary: Fastest Url parser in the world
 Author-Email: Mohammad Raziei <mohammadraziei1375@gmail.com>
 Classifier: Development Status :: 4 - Beta
@@ -39,7 +39,7 @@ Description-Content-Type: text/markdown
 [![forks - liburlparser](https://img.shields.io/github/forks/mohammadraziei/liburlparser?style=social)](https://github.com/mohammadraziei/liburlparser)
 
 [![PyPi](https://img.shields.io/pypi/v/liburlparser.svg)](https://pypi.org/project/liburlparser/)
-![Python](https://img.shields.io/badge/Python-3.8%20%7C%203.9%20%7C%203.10%20%7C%203.11-blue)
+![Python](https://img.shields.io/badge/Python-3.10%20%7C%203.11%20%7C%203.12-blue)
 ![Cpp](https://img.shields.io/badge/C++-17-blue)
 
 [![GitHub release](https://img.shields.io/github/release/mohammadraziei/liburlparser?include_prereleases=&sort=semver&color=purple)](https://github.com/mohammadraziei/liburlparser/releases/)
@@ -240,49 +240,102 @@ you can see all methods in python we can use in c++ very easily
 
 ## Installation
 
-### C++:
+### C++
+
+Requires a C++17 compiler and CMake >= 3.19. The library is a static library plus one header (`urlparser.h`),
+and its CMake target is **`liburlparser::urlparser`** - the same name no matter how you get it:
+
+#### 1. FetchContent
 
-#### build steps:
+```cmake
+include(FetchContent)
+FetchContent_Declare(
+  liburlparser
+  GIT_REPOSITORY https://github.com/mohammadraziei/liburlparser.git
+  GIT_TAG        master
+)
+FetchContent_MakeAvailable(liburlparser)
+
+target_link_libraries(my_app PRIVATE liburlparser::urlparser)
+```
+
+#### 2. From the pip package
+
+The Python wheel also ships the compiled C++ library, its header and a CMake
+package config (same idea as `python -m nanobind --cmake_dir`), so a C++
+project can use a plain `pip install liburlparser` without building anything:
+
+```cmake
+find_package(Python3 REQUIRED COMPONENTS Interpreter)
+execute_process(
+    COMMAND ${Python3_EXECUTABLE} -m liburlparser --cmake-dir
+    OUTPUT_VARIABLE liburlparser_DIR
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    COMMAND_ERROR_IS_FATAL ANY)
+
+find_package(liburlparser CONFIG REQUIRED)
+target_link_libraries(my_app PRIVATE liburlparser::urlparser)
+```
+
+For build systems that prefer plain paths over the target, `find_package` also sets:
+
+| Variable                 | Value                                                              |
+| ------------------------ | ------------------------------------------------------------------ |
+| `urlparser_LIB_PATH`     | full path of the compiled library (`liburlparser.a`, `urlparser.lib`, ...) |
+| `urlparser_INCLUDE_PATH` | directory containing `urlparser.h`                                 |
+
+The same locations are available from the command line and from Python:
 
 ```sh
-# 1. Clone the repository with submodules (recursive)
-# --recursive is essential to download third-party libs like googletest
-git clone --recursive https://github.com/mohammadraziei/liburlparser
-cd liburlparser
+python -m liburlparser --cmake-dir     # directory with liburlparserConfig.cmake
+python -m liburlparser --include-dir   # directory with urlparser.h
+python -m liburlparser --lib-dir       # directory with the compiled library
+```
+
+```python
+import liburlparser
+liburlparser.get_cmake_dir(), liburlparser.get_include_dir(), liburlparser.get_lib_dir()
+```
 
-# 2. Configure the project
-# -B build tells CMake to create a 'build' directory and generate files there
-cmake -B build
+A complete example project is in
+[examples/find_liburlparser_via_python](examples/find_liburlparser_via_python).
 
-# 3. Build the project
-# --build abstracts the underlying build tool (Make, Ninja, MSBuild, etc.)
-cmake --build build --config Debug
+#### 3. Build and install from source
 
-# 4. Run examples
-# Note: On Windows, the path might be ./build/Debug/example.exe
+```sh
+git clone https://github.com/mohammadraziei/liburlparser
+cd liburlparser
+
+# configure and build (-B creates the 'build' directory)
+cmake -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build
+
+# run the example (on Windows with multi-config generators: ./build/Release/example.exe)
 ./build/example
 
-# 5. Make install
-# --install handles the installation process
-sudo cmake --install build
+# install the library, header and CMake package (add --prefix <dir> to choose where)
+cmake --install build
+```
+
+Then, in your project (add `-DCMAKE_PREFIX_PATH=<prefix>` if you used a custom prefix):
+
+```cmake
+find_package(liburlparser CONFIG REQUIRED)
+target_link_libraries(my_app PRIVATE liburlparser::urlparser)
 ```
 
 ### Python and Command Line:
 
-Be aware that it required `python>=3.8`
+Be aware that it requires `python>=3.10`
 
 #### Installation
 
 ###### from source
 
-To install from source, you must ensure all submodules are cloned:
-
 ```bash
-# 1. Clone recursively to get third-party dependencies
-git clone --recursive https://github.com/mohammadraziei/liburlparser
+git clone https://github.com/mohammadraziei/liburlparser
 cd liburlparser
 
-# 2. Install using pip
 pip install .
 
 # Optional: If you want to see build logs
@@ -314,6 +367,18 @@ pip install ./liburlparser
 
 ### Performance
 
+Up-to-date, reproducible results for both C++ and Python (compared against other libraries)
+are on the **[Benchmarks page](https://mohammadraziei.github.io/liburlparser/benchmarks/)**.
+The report is generated locally and published with the documentation:
+
+```sh
+cmake -S benchmarks -B build-bench -DCMAKE_BUILD_TYPE=Release
+cmake --build build-bench --target urlparser_benchmarks_report
+# -> benchmarks/results/report.html
+```
+
+The two tables below are the original measurements from March 2022.
+
 #### Extract From Host
 
 Tests were run on a file containing 10 million random domains from various top-level domains (Mar. 13rd 2022)
@@ -354,5 +419,6 @@ Project Link:
 
 - [https://github.com/mohammadraziei/liburlparser](https://github.com/mohammadraziei/liburlparser)
 - [https://pypi.org/project/liburlparser](https://pypi.org/project/liburlparser)
+- [Documentation](https://mohammadraziei.github.io/liburlparser/) and [Benchmarks](https://mohammadraziei.github.io/liburlparser/benchmarks/)
 
 [license-shield]: https://img.shields.io/github/license/othneildrew/Best-README-Template.svg?style=flat-square