pyrematch 1.0.0__tar.gz

pyrematch-1.0.0/CMakeLists.txt

@@ -0,0 +1,71 @@
+cmake_minimum_required(VERSION 3.23.2)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+project(rematch LANGUAGES CXX)
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+set(project_LIB ${PROJECT_NAME}lib)
+# Use all cores but one for compilation
+include(ProcessorCount)
+ProcessorCount(NUM_CORES)
+if(NUM_CORES GREATER 1)
+    math(EXPR PARALLEL_LEVEL "${NUM_CORES} - 1")
+    set(CMAKE_BUILD_PARALLEL_LEVEL ${PARALLEL_LEVEL})
+endif()
+
+# Enable testing
+set(REMATCH_BUILD_TESTING OFF)
+# Enable profiling
+set(ENABLE_PROFILING OFF CACHE BOOL "Enable Profiling" FORCE)
+
+
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+  message(STATUS "Build type not specified. Using Release by default.")
+else()
+  message(STATUS "Using ${CMAKE_BUILD_TYPE} configuration")
+endif()
+
+if(SKBUILD)
+  # Enables PIC for all targets
+  set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+endif()
+
+if (MSVC)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
+  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Od /Zi")
+  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /O2")
+else()
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra")
+  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g3")
+  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -g0 -pedantic")
+endif()
+
+set(EXECUTABLE_OUTPUT_PATH "${PROJECT_BINARY_DIR}/bin")
+set(LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin")
+
+
+include_directories(src/rematch)
+add_subdirectory(src/rematch)
+
+
+# Tracy
+include(cmake/setup_tracy.cmake)
+# ANTLR
+add_subdirectory("${CMAKE_SOURCE_DIR}/third_party/antlr4-cpp-runtime")
+include_directories("${CMAKE_SOURCE_DIR}/third_party/antlr4-cpp-runtime/src")
+
+
+include_directories(src/targets)
+add_subdirectory(src/targets)
+
+if(REMATCH_BUILD_TESTING)
+  if(ENABLE_PROFILING)
+    message(STATUS "Skipped testing build due to profiling.")
+  elseif(SKBUILD)
+    message(STATUS "Skipped testing build due to SKBUILD.")
+  elseif(EMSCRIPTEN)
+    message(STATUS "Skipped testing build due to EMSCRIPTEN.")
+  else()
+    add_subdirectory(tests)
+  endif()
+endif()

pyrematch-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 REmatchChile
+
+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.

pyrematch-1.0.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: pyrematch
+Version: 1.0.0
+Summary: Python bindings for REmatch, an information extraction focused regex library that uses constant delay algoirthms
+Home-page: https://rematch.cl/
+Author: Vicente Calisto, Oscar Cárcamo, Nicolás Van Sint Jan, Gustavo Toro
+Author-email: vecalisto@uc.cl, oscar.carcamoz@uc.cl, nicovsj@uc.cl, gustavo.toro@uc.cl
+License: MIT
+Keywords: regex,rematch,regular,information extraction,text search,pattern matching
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# PyREmatch
+
+Python bindings for REmatch, an information extraction focused regex library that uses constant delay algoirthms

pyrematch-1.0.0/cmake/setup_pybind11.cmake

@@ -0,0 +1,17 @@
+include(FetchContent)
+
+message("Fetching pybind11")
+
+set(FETCHCONTENT_QUIET FALSE)
+
+FetchContent_Declare(
+  pybind11
+  URL https://github.com/pybind/pybind11/archive/refs/tags/v2.11.1.tar.gz
+)
+
+FetchContent_GetProperties(pybind11)
+
+if(NOT pybind11_POPULATED)
+    FetchContent_Populate(pybind11)
+    add_subdirectory(${pybind11_SOURCE_DIR} ${pybind11_BINARY_DIR})
+endif()

pyrematch-1.0.0/cmake/setup_tracy.cmake

@@ -0,0 +1,22 @@
+include(FetchContent)
+
+message("Fetching Tracy")
+
+Set(FETCHCONTENT_QUIET FALSE)
+
+FetchContent_Declare (
+  tracy
+  GIT_REPOSITORY https://github.com/wolfpld/tracy.git
+  GIT_TAG master
+  GIT_SHALLOW TRUE
+)
+
+if (ENABLE_PROFILING)
+  set(TRACY_ENABLE ON CACHE BOOL "Enable Tracy" FORCE)
+  set(TRACY_NO_EXIT ON CACHE BOOL "No Exit Tracy" FORCE)
+  set(TRACY_DEBUGINFOD ON CACHE BOOL "Use DEBUGINFOD Tracy" FORCE)
+else()
+  set(TRACY_ENABLE OFF CACHE BOOL "Disable Tracy" FORCE)
+endif()
+
+FetchContent_MakeAvailable(tracy)

pyrematch-1.0.0/pyproject.toml

@@ -0,0 +1,8 @@
+[build-system]
+requires = [
+    "setuptools",
+    "scikit-build",
+    "wheel",
+    "cmake>=3.23.2",
+]
+build-backend = "setuptools.build_meta"

pyrematch-1.0.0/python/pyrematch/README.md

@@ -0,0 +1,3 @@
+# PyREmatch
+
+Python bindings for REmatch, an information extraction focused regex library that uses constant delay algoirthms

pyrematch-1.0.0/python/pyrematch/__init__.py

@@ -0,0 +1,39 @@
+from .pyrematch import Flags, reql
+
+__version__ = "1.0.0"
+
+from ._pyrematch import (
+    AnchorInsideCaptureException,
+    ComplexQueryException,
+    EmptyWordCaptureException,
+    InvalidCharacterException,
+    InvalidEscapeException,
+    InvalidRangeException,
+    MemoryLimitExceededException,
+    QuerySyntaxException,
+    SameNestedVariableException,
+    UnhandledExpressionException,
+    VariableLimitExceededException,
+    VariableNotFoundException,
+    VariableNotFoundInCatalogException,
+    MultiSpannersNotAllowedException,
+)
+
+__all__ = [
+    "reql",
+    "Flags",
+    "QuerySyntaxException",
+    "AnchorInsideCaptureException",
+    "ComplexQueryException",
+    "EmptyWordCaptureException",
+    "InvalidCharacterException",
+    "InvalidEscapeException",
+    "InvalidRangeException",
+    "MemoryLimitExceededException",
+    "SameNestedVariableException",
+    "UnhandledExpressionException",
+    "VariableLimitExceededException",
+    "VariableNotFoundException",
+    "VariableNotFoundInCatalogException",
+    "MultiSpannersNotAllowedException",
+]

pyrematch-1.0.0/python/pyrematch/pyrematch.py

@@ -0,0 +1,168 @@
+import enum
+from typing import List, Tuple, Union
+
+from ._pyrematch import (
+    PyFlags,
+    PyMatch,
+    PyMatchIterator,
+    PyMultiQuery,
+    PyMultiMatch,
+    PyMultiMatchIterator,
+    PyQuery,
+)
+
+
+class Flags(enum.Flag):
+    NOFLAG = enum.auto()
+    LINE_BY_LINE = enum.auto()
+    MULTI_MATCH = enum.auto()
+
+    def _get_pyflags(self) -> "PyFlags":
+        pyflags = PyFlags()
+        pyflags.line_by_line = Flags.LINE_BY_LINE in self
+
+        return pyflags
+
+
+def reql(
+    pattern: str,
+    flags: Flags = Flags.NOFLAG,
+    max_mempool_duplications=8,
+    max_deterministic_states=1000,
+):
+    if Flags.MULTI_MATCH in flags:
+        return MultiQuery(
+            pattern, flags, max_mempool_duplications, max_deterministic_states
+        )
+    return Query(pattern, flags, max_mempool_duplications, max_deterministic_states)
+
+
+class Match:
+    def __init__(self, pymatch: "PyMatch"):
+        self._pymatch = pymatch
+
+    def start(self, variable: Union[str, int]) -> int:
+        return self._pymatch.start(variable)
+
+    def end(self, variable: Union[str, int]) -> int:
+        return self._pymatch.end(variable)
+
+    def span(self, variable: Union[str, int]) -> Tuple[int, int]:
+        return self._pymatch.span(variable)
+
+    def group(self, variable: Union[str, int]) -> str:
+        return self._pymatch.group(variable)
+
+    def empty(self) -> bool:
+        return self._pymatch.empty()
+
+    def variables(self) -> List[str]:
+        return self._pymatch.variables()
+
+    def __repr__(self) -> str:
+        variable_repr = [
+            f"{variable} -> [{self.start(variable)}, {self.end(variable)}>"
+            for variable in self.variables()
+        ]
+
+        if variable_repr:
+            return "\n".join(variable_repr)
+
+        return "Empty match"
+
+
+class MatchIterator:
+    def __init__(self, document: str, pyquery: "PyQuery"):
+        self._match_iterator: "PyMatchIterator" = pyquery.finditer(document)
+
+    def __iter__(self) -> "MatchIterator":
+        return self
+
+    def __next__(self) -> Match:
+        pymatch = self._match_iterator.next()
+        if pymatch:
+            return Match(pymatch)
+        raise StopIteration
+
+    def variables(self) -> List[str]:
+        return self._match_iterator.variables()
+
+
+class Query:
+    def __init__(
+        self,
+        pattern: str,
+        flags: Flags = Flags.NOFLAG,
+        max_mempool_duplications=8,
+        max_deterministic_states=1000,
+    ):
+        pyflags = flags._get_pyflags()
+        pyflags.max_mempool_duplications = max_mempool_duplications
+        pyflags.max_deterministic_states = max_deterministic_states
+        self._pyquery: "PyQuery" = PyQuery(pattern, pyflags)
+
+    def finditer(self, document: str) -> MatchIterator:
+        return MatchIterator(document, self._pyquery)
+
+    def findone(self, document: str) -> "Match":
+        return Match(self._pyquery.findone(document))
+
+    def check(self, document: str) -> bool:
+        return self._pyquery.check(document)
+
+
+class MultiMatch:
+    def __init__(self, pymatch: "PyMultiMatch"):
+        self._pymatch = pymatch
+
+    def spans(self, variable: Union[str, int]) -> List[Tuple[int, int]]:
+        return self._pymatch.spans(variable)
+
+    def groups(self, variable: Union[str, int]) -> List[str]:
+        return self._pymatch.groups(variable)
+
+    def submatch(self, span: Tuple[int, int]) -> "MultiMatch":
+        return MultiMatch(self._pymatch.submatch(span))
+
+    def empty(self) -> bool:
+        return self._pymatch.empty()
+
+
+class MultiMatchIterator:
+    def __init__(self, document: str, pyquery: "PyMultiQuery"):
+        self._match_iterator: "PyMultiMatchIterator" = pyquery.finditer(document)
+
+    def __iter__(self) -> "MultiMatchIterator":
+        return self
+
+    def __next__(self) -> MultiMatch:
+        pymatch = self._match_iterator.next()
+        if pymatch:
+            return MultiMatch(pymatch)
+        raise StopIteration
+
+    def variables(self) -> List[str]:
+        return self._match_iterator.variables()
+
+
+class MultiQuery:
+    def __init__(
+        self,
+        pattern: str,
+        flags: Flags = Flags.NOFLAG,
+        max_mempool_duplications=8,
+        max_deterministic_states=1000,
+    ):
+        pyflags = flags._get_pyflags()
+        pyflags.max_mempool_duplications = max_mempool_duplications
+        pyflags.max_deterministic_states = max_deterministic_states
+        self._pyquery: "PyMultiQuery" = PyMultiQuery(pattern, pyflags)
+
+    def finditer(self, document: str) -> MultiMatchIterator:
+        return MultiMatchIterator(document, self._pyquery)
+
+    def findone(self, document: str) -> "MultiMatch":
+        return MultiMatch(self._pyquery.findone(document))
+
+    def check(self, document: str) -> bool:
+        return self._pyquery.check(document)

pyrematch-1.0.0/python/pyrematch.egg-info/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: pyrematch
+Version: 1.0.0
+Summary: Python bindings for REmatch, an information extraction focused regex library that uses constant delay algoirthms
+Home-page: https://rematch.cl/
+Author: Vicente Calisto, Oscar Cárcamo, Nicolás Van Sint Jan, Gustavo Toro
+Author-email: vecalisto@uc.cl, oscar.carcamoz@uc.cl, nicovsj@uc.cl, gustavo.toro@uc.cl
+License: MIT
+Keywords: regex,rematch,regular,information extraction,text search,pattern matching
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# PyREmatch
+
+Python bindings for REmatch, an information extraction focused regex library that uses constant delay algoirthms