RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
refactor(parser): move native PDF/Office extraction into deepdoc facade (#20273)
xugangqiang25cd84732461
diff --git a/docker/nginx/ragflow.conf b/docker/nginx/ragflow.confindex 51b0f7fa81..1e45825f99 100644--- a/docker/nginx/ragflow.conf+++ b/docker/nginx/ragflow.conf@@ -31,4 +31,4 @@ server {expires 10y;access_log off;}-}\ No newline at end of file+}diff --git a/internal/agent/templates/deep_research.json b/internal/agent/templates/deep_research.jsonindex 1b76fe7b48..59c35dcb52 100644--- a/internal/agent/templates/deep_research.json+++ b/internal/agent/templates/deep_research.json@@ -864,4 +864,4 @@"retrieval": []},"avatar": "data:image/png;base64,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"- }\ No newline at end of file+ }diff --git a/internal/agent/templates/photo_text_translator.json b/internal/agent/templates/photo_text_translator.jsonindex 148c819467..f95734b864 100644--- a/internal/agent/templates/photo_text_translator.json+++ b/internal/agent/templates/photo_text_translator.json@@ -266,4 +266,4 @@"retrieval": []},"avatar": "data:image/png;base64,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"-}\ No newline at end of file+}diff --git a/internal/deepdoc/parser/office/engine.go b/internal/deepdoc/parser/office/engine.gonew file mode 100644index 0000000000..5aa6e96508--- /dev/null+++ b/internal/deepdoc/parser/office/engine.go@@ -0,0 +1,23 @@+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package office++import "errors"++// ErrOfficeCGORequired is returned by OpenAndExtract when the build has no+// native office_oxide backend. The parser package wraps it into its own+// ErrOfficeCGORequired so callers observe a stable sentinel regardless of+// which layer reports the missing engine.+var ErrOfficeCGORequired = errors.New("deepdoc/docx: cgo required")diff --git a/internal/deepdoc/parser/office/engine_cgo.go b/internal/deepdoc/parser/office/engine_cgo.gonew file mode 100644index 0000000000..138422b18f--- /dev/null+++ b/internal/deepdoc/parser/office/engine_cgo.go@@ -0,0 +1,61 @@+//go:build cgo++// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package office++import (+ "errors"+ "fmt"++ officeOxide "github.com/yfedoseev/office_oxide/go"+)++// OpenAndExtract opens an Office document with the native office_oxide+// backend and returns its three text views: the structured IR JSON, the+// Markdown rendering, and the raw plain text. The only place that depends on+// office_oxide lives here, so the parser package can stay CGO-free and own+// only the format-agnostic post-processing.+//+// A single failing view is non-fatal: the parser package salvages the+// surviving views (e.g. the DOCX JSON path errors on empty IR, the Markdown+// path prefers the Markdown view, the DOC path picks the longest view). mdErr+// is returned separately so the Markdown path can fail loud when only the+// Markdown view fails. If EVERY view fails there is nothing to recover, so err+// is set to the joined view errors instead of three empty strings that+// downstream code would silently treat as "empty document" (PR review+// Finding 1).+func OpenAndExtract(data []byte, format string) (irJSON, markdown, plainText string, mdErr error, err error) {+ doc, openErr := officeOxide.OpenFromBytes(data, format)+ if openErr != nil {+ return "", "", "", nil, fmt.Errorf("office_oxide open %s: %w", format, openErr)+ }+ defer doc.Close()++ irJSON, irErr := doc.ToIRJSON()+ markdown, mdErr = doc.ToMarkdown()+ plainText, ptErr := doc.PlainText()++ // Every view failed: nothing to salvage, so report the combined failures+ // rather than returning three empty strings that downstream code would+ // silently treat as an empty document (PR review Finding 1).+ if irJSON == "" && markdown == "" && plainText == "" {+ return "", "", "", mdErr, fmt.Errorf(+ "office_oxide %s: all text views failed: %w",+ format, errors.Join(irErr, mdErr, ptErr),+ )+ }+ return irJSON, markdown, plainText, mdErr, nil+}diff --git a/internal/deepdoc/parser/office/engine_cgo_test.go b/internal/deepdoc/parser/office/engine_cgo_test.gonew file mode 100644index 0000000000..f3bec5789b--- /dev/null+++ b/internal/deepdoc/parser/office/engine_cgo_test.go@@ -0,0 +1,90 @@+//go:build cgo++// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package office++import (+ "archive/zip"+ "bytes"+ "strings"+ "testing"+)++// TestOpenAndExtract_ValidDocReturnsViews locks the happy path of the+// revised 5-value OpenAndExtract contract under cgo: a real document yields a+// non-empty Markdown view and a nil error, and the Markdown error (mdErr) is+// surfaced as a distinct return so callers can fail loud when only that view+// fails (PR review Finding 1 + Finding 3). office_oxide always returns a+// structured IR for an openable document, so the all-views-empty join branch+// is exercised indirectly via the parser package's stub tests, not here.+func TestOpenAndExtract_ValidDocReturnsViews(t *testing.T) {+ data := minimalDOCX(t, "surviving content")+ irJSON, markdown, plainText, mdErr, err := OpenAndExtract(data, "docx")+ if err != nil {+ t.Fatalf("expected success for a document with content, got err: %v", err)+ }+ if strings.TrimSpace(irJSON) == "" {+ t.Error("expected non-empty IR for a document with content")+ }+ if strings.TrimSpace(markdown) == "" {+ t.Error("expected non-empty markdown for a document with content")+ }+ if strings.TrimSpace(plainText) == "" {+ t.Error("expected non-empty plain text for a document with content")+ }+ // A clean document has no Markdown render error to surface.+ if mdErr != nil {+ t.Errorf("expected nil mdErr for a clean document, got: %v", mdErr)+ }+ _ = plainText+}++func minimalDOCX(t *testing.T, text string) []byte {+ t.Helper()+ var buf bytes.Buffer+ zw := zip.NewWriter(&buf)+ writeZip(t, zw, "[Content_Types].xml", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">+ <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>+ <Default Extension="xml" ContentType="application/xml"/>+ <Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>+</Types>`)+ writeZip(t, zw, "_rels/.rels", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">+ <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/>+</Relationships>`)+ writeZip(t, zw, "word/document.xml", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>+<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">+ <w:body>+ <w:p><w:r><w:t>`+text+`</w:t></w:r></w:p>+ </w:body>+</w:document>`)+ if err := zw.Close(); err != nil {+ t.Fatalf("zip close: %v", err)+ }+ return buf.Bytes()+}++func writeZip(t *testing.T, zw *zip.Writer, name, body string) {+ t.Helper()+ w, err := zw.Create(name)+ if err != nil {+ t.Fatalf("create zip entry %s: %v", name, err)+ }+ if _, err := w.Write([]byte(body)); err != nil {+ t.Fatalf("write zip entry %s: %v", name, err)+ }+}diff --git a/internal/deepdoc/parser/office/engine_nocgo.go b/internal/deepdoc/parser/office/engine_nocgo.gonew file mode 100644index 0000000000..dcc10048df--- /dev/null+++ b/internal/deepdoc/parser/office/engine_nocgo.go@@ -0,0 +1,24 @@+//go:build !cgo++// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package office++import "fmt"++// OpenAndExtract is unavailable without the native office_oxide backend.+func OpenAndExtract(data []byte, format string) (irJSON, markdown, plainText string, mdErr error, err error) {+ return "", "", "", nil, fmt.Errorf("%w", ErrOfficeCGORequired)+}diff --git a/internal/deepdoc/parser/office/engine_nocgo_test.go b/internal/deepdoc/parser/office/engine_nocgo_test.gonew file mode 100644index 0000000000..9d9568f996--- /dev/null+++ b/internal/deepdoc/parser/office/engine_nocgo_test.go@@ -0,0 +1,36 @@+//go:build !cgo++// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package office++import (+ "errors"+ "testing"+)++// TestOpenAndExtract_NoCGO locks the degrade contract: without the native+// office_oxide backend, OpenAndExtract must report ErrOfficeCGORequired+// (not attempt to link the C library or panic). This is the behavior the+// parser package's facade relies on to wrap it into its own sentinel.+func TestOpenAndExtract_NoCGO(t *testing.T) {+ _, _, _, _, err := OpenAndExtract([]byte("PK\x03\x04"), "docx")+ if err == nil {+ t.Fatal("expected ErrOfficeCGORequired, got nil")+ }+ if !errors.Is(err, ErrOfficeCGORequired) {+ t.Fatalf("err = %v, want ErrOfficeCGORequired", err)+ }+}diff --git a/internal/deepdoc/parser/docx/parser.go b/internal/deepdoc/parser/office/parser.gosimilarity index 99%rename from internal/deepdoc/parser/docx/parser.gorename to internal/deepdoc/parser/office/parser.goindex a13ed80cb4..b6120381f9 100644--- a/internal/deepdoc/parser/docx/parser.go+++ b/internal/deepdoc/parser/office/parser.go@@ -1,4 +1,4 @@-package docx+package officeimport ("strings"diff --git a/internal/deepdoc/parser/docx/parser_integration_test.go b/internal/deepdoc/parser/office/parser_integration_test.gosimilarity index 99%rename from internal/deepdoc/parser/docx/parser_integration_test.gorename to internal/deepdoc/parser/office/parser_integration_test.goindex 675e2e196f..cc3e9fd121 100644--- a/internal/deepdoc/parser/docx/parser_integration_test.go+++ b/internal/deepdoc/parser/office/parser_integration_test.go@@ -1,6 +1,6 @@//go:build cgo && manual-package docx+package officeimport ("os"diff --git a/internal/deepdoc/parser/docx/parser_test.go b/internal/deepdoc/parser/office/parser_test.gosimilarity index 99%rename from internal/deepdoc/parser/docx/parser_test.gorename to internal/deepdoc/parser/office/parser_test.goindex 60dcf07473..16fdd906e0 100644--- a/internal/deepdoc/parser/docx/parser_test.go+++ b/internal/deepdoc/parser/office/parser_test.go@@ -1,4 +1,4 @@-package docx+package officeimport ("testing"diff --git a/internal/deepdoc/parser/docx/raw_blocks_test.go b/internal/deepdoc/parser/office/raw_blocks_test.gosimilarity index 99%rename from internal/deepdoc/parser/docx/raw_blocks_test.gorename to internal/deepdoc/parser/office/raw_blocks_test.goindex c1174f7a21..955be405c2 100644--- a/internal/deepdoc/parser/docx/raw_blocks_test.go+++ b/internal/deepdoc/parser/office/raw_blocks_test.go@@ -1,6 +1,6 @@//go:build cgo && manual-package docx+package officeimport ("encoding/json"diff --git a/internal/deepdoc/parser/docx/reader.go b/internal/deepdoc/parser/office/reader.gosimilarity index 99%rename from internal/deepdoc/parser/docx/reader.gorename to internal/deepdoc/parser/office/reader.goindex b3a5c3677d..2fe32f0417 100644--- a/internal/deepdoc/parser/docx/reader.go+++ b/internal/deepdoc/parser/office/reader.go@@ -1,6 +1,6 @@//go:build cgo-package docx+package officeimport ("encoding/base64"diff --git a/internal/deepdoc/parser/docx/reader_cell_test.go b/internal/deepdoc/parser/office/reader_cell_test.gosimilarity index 98%rename from internal/deepdoc/parser/docx/reader_cell_test.gorename to internal/deepdoc/parser/office/reader_cell_test.goindex 4183cf378c..d7b6d4c2fe 100644--- a/internal/deepdoc/parser/docx/reader_cell_test.go+++ b/internal/deepdoc/parser/office/reader_cell_test.go@@ -1,6 +1,6 @@//go:build cgo-package docx+package officeimport "testing"diff --git a/internal/deepdoc/parser/docx/reader_stub.go b/internal/deepdoc/parser/office/reader_stub.gosimilarity index 95%rename from internal/deepdoc/parser/docx/reader_stub.gorename to internal/deepdoc/parser/office/reader_stub.goindex ed7c993544..f8d4d65cb7 100644--- a/internal/deepdoc/parser/docx/reader_stub.go+++ b/internal/deepdoc/parser/office/reader_stub.go@@ -1,6 +1,6 @@//go:build !cgo-package docx+package officeimport "errors"diff --git a/internal/deepdoc/parser/docx/reader_style_test.go b/internal/deepdoc/parser/office/reader_style_test.gosimilarity index 98%rename from internal/deepdoc/parser/docx/reader_style_test.gorename to internal/deepdoc/parser/office/reader_style_test.goindex dd7b054ff6..f02eaee998 100644--- a/internal/deepdoc/parser/docx/reader_style_test.go+++ b/internal/deepdoc/parser/office/reader_style_test.go@@ -1,6 +1,6 @@//go:build cgo-package docx+package officeimport "testing"diff --git a/internal/deepdoc/parser/docx/types.go b/internal/deepdoc/parser/office/types.gosimilarity index 99%rename from internal/deepdoc/parser/docx/types.gorename to internal/deepdoc/parser/office/types.goindex 21c3c56959..448851e0af 100644--- a/internal/deepdoc/parser/docx/types.go+++ b/internal/deepdoc/parser/office/types.go@@ -1,4 +1,4 @@-package docx+package office// RawBlock represents a single block extracted from a DOCX file in document order.// Type is one of "paragraph", "table", or "image". Headings are represented asdiff --git a/internal/deepdoc/parser/pdf/plaintext_cgo.go b/internal/deepdoc/parser/pdf/plaintext_cgo.gonew file mode 100644index 0000000000..3539862af9--- /dev/null+++ b/internal/deepdoc/parser/pdf/plaintext_cgo.go@@ -0,0 +1,56 @@+//go:build cgo++// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package pdf++import (+ "fmt"++ "ragflow/internal/deepdoc/parser/pdf/pdfoxide"+)++// PlainText extracts plain text per page using the pdf_oxide native engine.+// It is the cgo implementation of the parser package's plain_text PDF+// strategy. The returned items carry the keys text/doc_type_kwd/page_number+// so the parser package can wrap them with pdfItemsToResult unchanged.+func PlainText(data []byte) ([]map[string]any, int, error) {+ if len(data) == 0 {+ return nil, 0, nil+ }+ doc, err := pdfoxide.OpenBytes(data)+ if err != nil {+ return nil, 0, fmt.Errorf("deepdoc/pdf: plain_text open: %w", err)+ }+ defer doc.Close()++ pageCount, err := doc.PageCount()+ if err != nil {+ return nil, 0, fmt.Errorf("deepdoc/pdf: plain_text page count: %w", err)+ }+ items := make([]map[string]any, 0, pageCount)+ for page := 0; page < pageCount; page++ {+ text, err := doc.GetPageText(page)+ if err != nil {+ return nil, 0, fmt.Errorf("deepdoc/pdf: plain_text page %d: %w", page+1, err)+ }+ items = append(items, map[string]any{+ "text": text,+ "doc_type_kwd": "text",+ "page_number": page + 1,+ })+ }+ return items, pageCount, nil+}diff --git a/internal/deepdoc/parser/pdf/plaintext_nocgo.go b/internal/deepdoc/parser/pdf/plaintext_nocgo.gonew file mode 100644index 0000000000..9df397a7da--- /dev/null+++ b/internal/deepdoc/parser/pdf/plaintext_nocgo.go@@ -0,0 +1,78 @@+//go:build !cgo++// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package pdf++import (+ "bytes"+ "fmt"+ "strings"++ "github.com/ledongthuc/pdf"+)++// maxPDFPageCount is the largest page count PlainText will accept. A corrupt+// or malicious /Count in the catalog can claim billions of pages; honoring it+// would either panic make (negative) or allocate/iterate without bound (huge).+// One million pages is far beyond any real document RAGFlow ingests, so values+// above it are treated as malformed (PR review Blocker).+const maxPDFPageCount = 1_000_000++// PlainText extracts plain text per page using the pure-Go ledongthuc/pdf+// engine. It mirrors the cgo pdf_oxide implementation so the parser package's+// plain_text strategy keeps working under !cgo builds without native+// libraries. The returned items carry the keys text/doc_type_kwd/page_number+// so the parser package can wrap them with pdfItemsToResult unchanged.+func PlainText(data []byte) ([]map[string]any, int, error) {+ if len(data) == 0 {+ return nil, 0, nil+ }+ reader := bytes.NewReader(data)+ pdfReader, err := pdf.NewReader(reader, int64(len(data)))+ if err != nil {+ return nil, 0, fmt.Errorf("deepdoc/pdf: plain_text open: %w", err)+ }+ pageCount := pdfReader.NumPage()+ // ledongthuc/pdf reads the catalog /Count verbatim, so a malformed PDF+ // can report a negative or absurd page count. Feeding that directly into+ // make would panic ("makeslice: cap out of range") and a huge count would+ // allocate a massive backing array or loop for billions of iterations,+ // hanging the ingestor on one corrupt file. Reject implausible counts up+ // front (PR review Blocker).+ if pageCount < 0 {+ return nil, 0, fmt.Errorf("deepdoc/pdf: plain_text: invalid negative page count %d", pageCount)+ }+ if pageCount > maxPDFPageCount {+ return nil, 0, fmt.Errorf("deepdoc/pdf: plain_text: page count %d exceeds sane limit %d", pageCount, maxPDFPageCount)+ }+ items := make([]map[string]any, 0, pageCount)+ for pageNum := 1; pageNum <= pageCount; pageNum++ {+ p := pdfReader.Page(pageNum)+ if p.V.IsNull() {+ continue+ }+ text, err := p.GetPlainText(nil)+ if err != nil {+ return nil, 0, fmt.Errorf("deepdoc/pdf: plain_text page %d: %w", pageNum, err)+ }+ items = append(items, map[string]any{+ "text": strings.TrimRight(text, "\n"),+ "doc_type_kwd": "text",+ "page_number": pageNum,+ })+ }+ return items, pageCount, nil+}diff --git a/internal/deepdoc/parser/pdf/plaintext_nocgo_test.go b/internal/deepdoc/parser/pdf/plaintext_nocgo_test.gonew file mode 100644index 0000000000..2d8695502d--- /dev/null+++ b/internal/deepdoc/parser/pdf/plaintext_nocgo_test.go@@ -0,0 +1,108 @@+//go:build !cgo++// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package pdf++import (+ "bytes"+ "fmt"+ "testing"+)++// TestPlainText_EmptyInput locks the empty-input contract: a nil/empty+// payload yields (nil, 0, nil) rather than an error, so the caller's+// empty-PDF short-circuit stays correct under the pure-Go engine.+func TestPlainText_EmptyInput(t *testing.T) {+ items, pageCount, err := PlainText(nil)+ if err != nil {+ t.Fatalf("err = %v, want nil", err)+ }+ if items != nil || pageCount != 0 {+ t.Fatalf("got (items=%v, pageCount=%d), want (nil, 0)", items, pageCount)+ }+}++// TestPlainText_GarbageReturnsError locks that non-PDF input fails loudly+// instead of silently producing empty items — the pure-Go ledongthuc/pdf+// path must surface a parse error, never a plausible empty success.+func TestPlainText_GarbageReturnsError(t *testing.T) {+ _, _, err := PlainText([]byte("this is not a pdf"))+ if err == nil {+ t.Fatal("expected error for non-PDF input, got nil")+ }+}++// TestPlainText_NegativePageCountDoesNotPanic locks the Blocker from the PR+// review: ledongthuc/pdf's NumPage() reads the catalog /Count verbatim, so a+// malformed (negative) /Count yields a negative page count. The old code fed+// that straight into make([]map[string]any, 0, pageCount), which panics with+// "makeslice: cap out of range". PlainText must validate the page count and+// fail loud instead of crashing the ingestor on a single corrupt PDF.+func TestPlainText_NegativePageCountDoesNotPanic(t *testing.T) {+ defer func() {+ if r := recover(); r != nil {+ t.Fatalf("PlainText panicked on a negative /Count: %v", r)+ }+ }()+ data := buildPDFWithCount(t, -1)+ _, _, err := PlainText(data)+ if err == nil {+ t.Fatal("expected error for a PDF with a negative /Count, got nil")+ }+}++// TestPlainText_HugePageCountDoesNotHang locks the sibling failure mode of the+// same Blocker: an absurd /Count must not allocate a gigantic slice or loop+// for billions of iterations. We cap the page count and reject grossly+// implausible values up front.+func TestPlainText_HugePageCountDoesNotHang(t *testing.T) {+ defer func() {+ if r := recover(); r != nil {+ t.Fatalf("PlainText panicked on a huge /Count: %v", r)+ }+ }()+ data := buildPDFWithCount(t, 1<<30)+ _, _, err := PlainText(data)+ if err == nil {+ t.Fatal("expected error for a PDF with a huge /Count, got nil")+ }+}++// buildPDFWithCount emits a minimal but structurally valid PDF whose /Pages+// /Count is set to the supplied value. Offsets are computed so the xref table+// is self-consistent and ledongthuc/pdf can open it, letting NumPage() observe+// the (possibly malformed) /Count.+func buildPDFWithCount(t *testing.T, count int) []byte {+ t.Helper()+ var buf bytes.Buffer+ buf.WriteString("%PDF-1.4\n")++ off1 := buf.Len()+ fmt.Fprintf(&buf, "1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n")+ off2 := buf.Len()+ fmt.Fprintf(&buf, "2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count %d >>\nendobj\n", count)+ off3 := buf.Len()+ fmt.Fprintf(&buf, "3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << >> >>\nendobj\n")++ xrefStart := buf.Len()+ buf.WriteString("xref\n0 4\n")+ buf.WriteString("0000000000 65535 f \n")+ fmt.Fprintf(&buf, "%010d 00000 n \n", off1)+ fmt.Fprintf(&buf, "%010d 00000 n \n", off2)+ fmt.Fprintf(&buf, "%010d 00000 n \n", off3)+ fmt.Fprintf(&buf, "trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n%d\n%%%%EOF\n", xrefStart)+ return buf.Bytes()+}diff --git a/internal/parser/parser/doc_parser.go b/internal/parser/parser/doc_parser.goindex 8bc8c4cdaa..295511eac4 100644--- a/internal/parser/parser/doc_parser.go+++ b/internal/parser/parser/doc_parser.go@@ -1,5 +1,3 @@-//go:build cgo-//// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.//@@ -7,25 +5,28 @@// you may not use this file except in compliance with the License.// You may obtain a copy of the License at//-// http://www.apache.org/licenses/LICENSE-2.0+// http://www.apache.org/licenses/LICENSE-2.0//// Unless required by applicable law or agreed to in writing, software// distributed under the License is distributed on an "AS IS" BASIS,// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.// See the License for the specific language governing permissions and// limitations under the License.-//package parserimport ("context"+ "errors""fmt""strings"- officeOxide "github.com/yfedoseev/office_oxide/go"+ deepdocoffice "ragflow/internal/deepdoc/parser/office")+// docExtract is the native office_oxide extraction seam for the DOC family.+var docExtract = deepdocoffice.OpenAndExtract+type DOCParser struct {OutputFormat string}@@ -52,13 +53,15 @@ func (p *DOCParser) ConfigureFromSetup(setup map[string]any) {// ParseWithResult extracts text for the DOC family and converts it to the// requested output format (defaulting to "json" to match Python's default).func (p *DOCParser) ParseWithResult(ctx context.Context, filename string, data []byte) ParseResult {- doc, err := officeOxide.OpenFromBytes(data, "doc")+ irJSON, mdText, plainText, _, err := docExtract(data, "doc")if err != nil {- return ParseResult{Err: fmt.Errorf("doc open: %w", err)}+ if errors.Is(err, deepdocoffice.ErrOfficeCGORequired) {+ return ParseResult{Err: fmt.Errorf("%w: %s", ErrOfficeCGORequired, filename)}+ }+ return ParseResult{Err: fmt.Errorf("doc extract: %w", err)}}- defer doc.Close()- text, mdText, err := extractDocText(doc)+ text, mdPayload, err := extractDocText(irJSON, mdText, plainText)if err != nil {return ParseResult{Err: fmt.Errorf("doc extract: %w", err)}}@@ -69,8 +72,8 @@ func (p *DOCParser) ParseWithResult(ctx context.Context, filename string, data [}markdownPayload := text- if strings.TrimSpace(mdText) != "" {- markdownPayload = mdText+ if strings.TrimSpace(mdPayload) != "" {+ markdownPayload = mdPayload}res := ParseResult{@@ -93,7 +96,8 @@ func (p *DOCParser) ParseWithResult(ctx context.Context, filename string, data [}// extractDocText returns the best-effort plain text for a legacy .doc-// document. office_oxide exposes three text views:+// document. office_oxide exposes three text views (documented on the cgo+// OpenAndExtract contract):// - ToIRJSON: a structured DocumentIR, flattened to plain text via// flattenDocIR. Recovers table structure (office_oxide/go v0.1.9, #116)// and, when the reader surfaces them, list structure.@@ -104,26 +108,24 @@ func (p *DOCParser) ParseWithResult(ctx context.Context, filename string, data [// unique to the IR view and would be silently dropped under a pure length// comparison — a prose-heavy document can make PlainText longer than the IR// even though the IR is more complete). Otherwise the longest non-empty view-// is chosen so a sparser view never shadows a more complete one. A failure at-// every stage degrades to the PlainText error, preserving the original "no-// text at all" failure semantics.-func extractDocText(doc *officeOxide.Document) (string, string, error) {- var irJSON, irText, mdText, plainText string- if j, err := doc.ToIRJSON(); err == nil {- irJSON = j- irText = flattenDocIR(j)- }- if md, err := doc.ToMarkdown(); err == nil {- mdText = md- }- if plain, err := doc.PlainText(); err == nil {- plainText = plain- } else if strings.TrimSpace(irText) == "" && strings.TrimSpace(mdText) == "" {- // Every view failed (or produced nothing): keep the original- // "no text at all" failure semantics.- return "", "", err- }- return selectDocTextView(irJSON, irText, mdText, plainText), mdText, nil+// is chosen so a sparser view never shadows a more complete one.+func extractDocText(irJSON, mdText, plainText string) (string, string, error) {+ var irText string+ if irJSON != "" {+ irText = flattenDocIR(irJSON)+ }+ text := selectDocTextView(irJSON, irText, mdText, plainText)+ // Fail loud when the document yielded no usable text in any view. The+ // OpenAndExtract contract swallows per-view errors, so an empty selected+ // view plus an empty Markdown view is the only signal we get that the+ // document has no extractable text — surfacing it avoids silently+ // producing 0 chunks (Finding A). A legitimately empty payload (e.g. a+ // scanned-image doc with OCR off) is rare and failing is safer than+ // silent data loss.+ if strings.TrimSpace(text) == "" && strings.TrimSpace(mdText) == "" {+ return "", "", fmt.Errorf("doc extract: no text content")+ }+ return text, mdText, nil}// selectDocTextView chooses the best plain-text rendering from office_oxide'sdiff --git a/internal/parser/parser/doc_text_empty_test.go b/internal/parser/parser/doc_text_empty_test.gonew file mode 100644index 0000000000..ee6b4ee621--- /dev/null+++ b/internal/parser/parser/doc_text_empty_test.go@@ -0,0 +1,33 @@+package parser++import (+ "errors"+ "testing"+)++// TestDOCParser_EmptyViewsReturnsError locks Finding A from the PR review:+// when the native office backend opens the document but yields no text in any+// of its three views (IR / Markdown / PlainText), ParseWithResult must surface+// an error instead of silently returning empty content (which would produce 0+// chunks with no signal). This restores the pre-PR "no text at all" fail-loud+// semantics that the string-returning OpenAndExtract contract would otherwise+// hide.+func TestDOCParser_EmptyViewsReturnsError(t *testing.T) {+ ctx := t.Context()+ p := NewDOCParser()++ orig := docExtract+ defer func() { docExtract = orig }()+ // Open succeeds, but all three views come back empty.+ docExtract = func(data []byte, format string) (string, string, string, error, error) {+ return "", "", "", nil, nil+ }++ res := p.ParseWithResult(ctx, "empty.doc", []byte("PK\x03\x04"))+ if res.Err == nil {+ t.Fatal("expected error for a document with no extractable text, got nil")+ }+ if errors.Is(res.Err, ErrOfficeCGORequired) {+ t.Fatalf("got ErrOfficeCGORequired, want a content-extraction error: %v", res.Err)+ }+}diff --git a/internal/parser/parser/docx_parser.go b/internal/parser/parser/docx_parser.goindex 77288fabb4..f691f653d4 100644--- a/internal/parser/parser/docx_parser.go+++ b/internal/parser/parser/docx_parser.go@@ -1,5 +1,3 @@-//go:build cgo-//// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.//@@ -7,36 +5,36 @@// you may not use this file except in compliance with the License.// You may obtain a copy of the License at//-// http://www.apache.org/licenses/LICENSE-2.0+// http://www.apache.org/licenses/LICENSE-2.0//// Unless required by applicable law or agreed to in writing, software// distributed under the License is distributed on an "AS IS" BASIS,// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.// See the License for the specific language governing permissions and// limitations under the License.-//package parserimport ("context"+ "errors""fmt""strings"- officeOxide "github.com/yfedoseev/office_oxide/go"+ deepdocoffice "ragflow/internal/deepdoc/parser/office")-// docxOpenFromBytes is a test seam that mirrors officeOxide.OpenFromBytes.-// Overridden in tests to capture the effective container format.-// Not safe for concurrent use with t.Parallel() — tests must save/restore-// it sequentially (see office_detect_cgo_test.go).-var docxOpenFromBytes = officeOxide.OpenFromBytes+// docxExtract is a test seam for the native office_oxide extraction. It+// defaults to the deepdoc/docx backend (which is the only place that depends+// on office_oxide) and is overridden in tests to capture the effective+// container format passed to the engine.+var docxExtract = deepdocoffice.OpenAndExtract-// DOCXParser is the cgo-backed DOCX parser. It is the only DOCX-// entrypoint that depends on office_oxide; the IR data model and-// postprocessing live in cgo-free files (docx_ir.go, docx_postprocess.go)-// so they compile and test without native libraries. The !cgo build-// provides a stub DOCXParser in office_parsers_no_cgo.go.+// DOCXParser is the DOCX/DOC parser. It is a CGO-free facade: magic-byte+// sniffing and post-processing live here, while the native extraction lives+// in internal/deepdoc/parser/office. The IR data model and postprocessing live+// in cgo-free files (docx_ir.go, docx_postprocess.go, office_table_render.go)+// so they compile and test without native libraries.type DOCXParser struct {libType stringoutputFormat string // from DSL config; "json" or "markdown"@@ -77,7 +75,7 @@ func (p *DOCXParser) ConfigureFromSetup(setup map[string]any) {// File["format"] in the returned ParseResult reflects the effective// container format after magic-byte sniffing (e.g. "doc" for an OLE// payload uploaded as .docx), not merely the file extension. See-// office_detect_cgo.go:officeContainer for the detection contract.+// office_detect.go:officeContainer for the detection contract.func (p *DOCXParser) ParseWithResult(ctx context.Context, filename string, data []byte) ParseResult {// office_oxide's OpenFromBytes takes the container format as given// and does no magic-byte detection, so a legacy .doc uploaded with a@@ -94,11 +92,13 @@ func (p *DOCXParser) ParseWithResult(ctx context.Context, filename string, data// opens the payload as ZIP and fails closed, so RemoveHeaderFooter becomes// a no-op for legacy OLE inputs. This is acceptable — legacy DOC has no// OOXML header/footer parts to strip.- doc, err := docxOpenFromBytes(data, format)+ irJSON, md, _, mdErr, err := docxExtract(data, format)if err != nil {- return ParseResult{Err: fmt.Errorf("docx open: %w", err)}+ if errors.Is(err, deepdocoffice.ErrOfficeCGORequired) {+ return ParseResult{Err: fmt.Errorf("%w: %s", ErrOfficeCGORequired, filename)}+ }+ return ParseResult{Err: fmt.Errorf("docx extract: %w", err)}}- defer doc.Close()fileMeta := map[string]any{"name": filename,@@ -106,14 +106,27 @@ func (p *DOCXParser) ParseWithResult(ctx context.Context, filename string, data}// Extract IR JSON for section building (JSON path) and- // embedded-image extraction on the Markdown path.- irJSON, irErr := doc.ToIRJSON()+ // embedded-image extraction (both paths). The budget bounds image+ // payloads so the downstream VLM enhancement stays within limits.+ budget := newEmbeddedMediaBudget()+ if irJSON != "" {+ figures := extractDOCXFiguresFromIR(irJSON, budget)+ if len(figures) > 0 {+ fileMeta["figures"] = buildFiguresMap(figures)+ }+ }if p.outputFormat == "json" {- if irErr != nil {- return ParseResult{Err: fmt.Errorf("docx to-ir-json: %w", irErr)}+ // The JSON path is built entirely from the structured IR, so an+ // empty IR is a fatal parse error for this output format — the+ // Markdown path below still has the plain-text fallback. The+ // OpenAndExtract contract swallows per-view errors, so we cannot+ // distinguish "IR failed" from "IR legitimately empty"; either way+ // the JSON path has nothing to build from, so we fail loud+ // (Finding B) rather than emit empty/garbage JSON sections.+ if irJSON == "" {+ return ParseResult{Err: fmt.Errorf("docx extract: empty IR, cannot build JSON output")}}- budget := newEmbeddedMediaBudget()sections := buildDOCXJSONSections(irJSON, budget)if err := ctx.Err(); err != nil {return ParseResult{Err: err}@@ -143,24 +156,20 @@ func (p *DOCXParser) ParseWithResult(ctx context.Context, filename string, data}}- budget := newEmbeddedMediaBudget()- if irErr == nil {- figures := extractDOCXFiguresFromIR(irJSON, budget)- if len(figures) > 0 {- fileMeta["figures"] = buildFiguresMap(figures)- }- }-// Default / Markdown path.- md, err := doc.ToMarkdown()- if err != nil {- return ParseResult{Err: fmt.Errorf("docx to-markdown: %w", err)}+ if mdErr != nil {+ // The Markdown view failed but other views survived. Surface the+ // Markdown render error rather than silently emitting empty markdown+ // (PR review Finding 3). The JSON path above is unaffected because it+ // is built from the IR view.+ return ParseResult{Err: fmt.Errorf("docx extract: markdown render failed: %w", mdErr)}}+ markdownPayload := md// remove_header_footer on Markdown: filter lines by exact match// (mirrors Python parser.py:923-926 split lines → filter → rejoin).if p.RemoveHeaderFooter {hfTexts := extractDOCXHeaderFooterTexts(data)- lines := strings.Split(md, "\n")+ lines := strings.Split(markdownPayload, "\n")lineItems := make([]map[string]any, 0, len(lines))for _, ln := range lines {lineItems = append(lineItems, map[string]any{"text": ln})@@ -170,13 +179,13 @@ func (p *DOCXParser) ParseWithResult(ctx context.Context, filename string, datafor _, item := range lineItems {rebuilt = append(rebuilt, itemText(item))}- md = strings.Join(rebuilt, "\n")+ markdownPayload = strings.Join(rebuilt, "\n")}// remove_toc on Markdown: split lines, filter, rejoin// (mirrors Python parser.py:927-928 remove_toc_word on Markdown).- if p.RemoveTOC && irErr == nil {+ if p.RemoveTOC && irJSON != "" {outlines := extractDOCXOutlines(irJSON)- lines := strings.Split(md, "\n")+ lines := strings.Split(markdownPayload, "\n")lineItems := make([]map[string]any, 0, len(lines))for _, ln := range lines {lineItems = append(lineItems, map[string]any{"text": ln})@@ -186,12 +195,12 @@ func (p *DOCXParser) ParseWithResult(ctx context.Context, filename string, datafor _, item := range filtered {rebuilt = append(rebuilt, itemText(item))}- md = strings.Join(rebuilt, "\n")+ markdownPayload = strings.Join(rebuilt, "\n")}return ParseResult{OutputFormat: "markdown",File: fileMeta,- Markdown: md,+ Markdown: markdownPayload,Warnings: budget.warnings(),}}diff --git a/internal/parser/parser/office_detect_cgo.go b/internal/parser/parser/office_detect.gosimilarity index 69%rename from internal/parser/parser/office_detect_cgo.gorename to internal/parser/parser/office_detect.goindex 7e8a3cb47c..d310f10d7f 100644--- a/internal/parser/parser/office_detect_cgo.go+++ b/internal/parser/parser/office_detect.go@@ -1,21 +1,3 @@-//go:build cgo--//-// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.-//-// Licensed under the Apache License, Version 2.0 (the "License");-// you may not use this file except in compliance with the License.-// You may obtain a copy of the License at-//-// http://www.apache.org/licenses/LICENSE-2.0-//-// Unless required by applicable law or agreed to in writing, software-// distributed under the License is distributed on an "AS IS" BASIS,-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.-// See the License for the specific language governing permissions and-// limitations under the License.-//-package parser// officeContainer reports the on-disk container format of an Officediff --git a/internal/parser/parser/office_detect_cgo_test.go b/internal/parser/parser/office_detect_test.gosimilarity index 55%rename from internal/parser/parser/office_detect_cgo_test.gorename to internal/parser/parser/office_detect_test.goindex 73e0b0e810..ad2ea035ee 100644--- a/internal/parser/parser/office_detect_cgo_test.go+++ b/internal/parser/parser/office_detect_test.go@@ -1,13 +1,8 @@-//go:build cgo-package parserimport (- "bytes""fmt""testing"-- officeOxide "github.com/yfedoseev/office_oxide/go")// TestOfficeContainer verifies the magic-byte sniffing that lets the@@ -51,13 +46,13 @@ func TestDOCXParser_FallsBackToDOCForOLEHeader(t *testing.T) {ctx := t.Context()p := NewDOCXParser()- orig := docxOpenFromBytes- defer func() { docxOpenFromBytes = orig }()+ orig := docxExtract+ defer func() { docxExtract = orig }()var gotFormat string- docxOpenFromBytes = func(data []byte, format string) (*officeOxide.Document, error) {+ docxExtract = func(data []byte, format string) (string, string, string, error, error) {gotFormat = format- return nil, fmt.Errorf("stub doc open: %s", format)+ return "", "", "", nil, fmt.Errorf("stub doc open: %s", format)}data := []byte{0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1}@@ -66,7 +61,77 @@ func TestDOCXParser_FallsBackToDOCForOLEHeader(t *testing.T) {t.Fatal("expected parse error for a non-document OLE header, got nil")}if gotFormat != "doc" {- t.Fatalf("docxOpenFromBytes format = %q, want %q (OLE fallback not triggered)", gotFormat, "doc")+ t.Fatalf("docxExtract format = %q, want %q (OLE fallback not triggered)", gotFormat, "doc")+ }+}++// TestDOCXParser_JSONEmptyIRReturnsError locks Finding B: when the native+// backend opens the document but returns an empty structured IR, the JSON+// output path must fail loud (it is built entirely from the IR, which the+// Markdown path can fall back from plain text). This guards against silently+// emitting empty JSON sections.+func TestDOCXParser_JSONEmptyIRReturnsError(t *testing.T) {+ ctx := t.Context()+ p := NewDOCXParser()+ p.ConfigureFromSetup(map[string]any{"output_format": "json"})++ orig := docxExtract+ defer func() { docxExtract = orig }()+ docxExtract = func(data []byte, format string) (string, string, string, error, error) {+ // Open succeeds, but the IR view is empty.+ return "", "", "", nil, nil+ }++ res := p.ParseWithResult(ctx, "empty.docx", []byte("PK\x03\x04"))+ if res.Err == nil {+ t.Fatal("expected error for JSON output with empty IR, got nil")+ }+}++// TestDOCXParser_MarkdownViewErrorPropagated locks Finding 3: when the+// native backend's Markdown view fails but the other views survive,+// OpenAndExtract surfaces the Markdown error via mdErr and the Markdown output+// path must fail loud instead of silently emitting empty markdown. The JSON+// path is unaffected because it is built from the IR view.+func TestDOCXParser_MarkdownViewErrorPropagated(t *testing.T) {+ ctx := t.Context()+ p := NewDOCXParser()+ p.ConfigureFromSetup(map[string]any{"output_format": "markdown"})++ orig := docxExtract+ defer func() { docxExtract = orig }()+ docxExtract = func(data []byte, format string) (string, string, string, error, error) {+ // IR and plain text survive; only the Markdown view fails.+ return "<ir/>", "", "plain text fallback", fmt.Errorf("markdown boom"), nil+ }++ res := p.ParseWithResult(ctx, "broken.docx", []byte("PK\x03\x04"))+ if res.Err == nil {+ t.Fatal("expected error when only the Markdown view fails, got nil")+ }+}++// TestDOCXParser_AllViewsEmptyMarkdownReturnsError locks the engine-level+// contract from Finding 1 at the parser boundary: when the native backend+// opens the document but every view (IR / Markdown / PlainText) is empty,+// OpenAndExtract reports a joined error, and the default Markdown output path+// must fail loud rather than silently emit empty markdown. (office_oxide+// always returns a structured IR for an openable doc, so this all-empty error+// is simulated via the seam rather than a real fixture.)+func TestDOCXParser_AllViewsEmptyMarkdownReturnsError(t *testing.T) {+ ctx := t.Context()+ p := NewDOCXParser()+ p.ConfigureFromSetup(map[string]any{"output_format": "markdown"})++ orig := docxExtract+ defer func() { docxExtract = orig }()+ docxExtract = func(data []byte, format string) (string, string, string, error, error) {+ return "", "", "", nil, fmt.Errorf("office_oxide docx: all text views failed")+ }++ res := p.ParseWithResult(ctx, "empty.docx", []byte("PK\x03\x04"))+ if res.Err == nil {+ t.Fatal("expected error for a document with no extractable text in any view, got nil")}}@@ -77,13 +142,13 @@ func TestDOCXParser_TruncatedOLENotFallback(t *testing.T) {ctx := t.Context()p := NewDOCXParser()- orig := docxOpenFromBytes- defer func() { docxOpenFromBytes = orig }()+ orig := docxExtract+ defer func() { docxExtract = orig }()var gotFormat string- docxOpenFromBytes = func(data []byte, format string) (*officeOxide.Document, error) {+ docxExtract = func(data []byte, format string) (string, string, string, error, error) {gotFormat = format- return nil, fmt.Errorf("stub")+ return "", "", "", nil, fmt.Errorf("stub")}data := []byte{0xD0, 0xCF, 0x11, 0xE0}@@ -96,40 +161,19 @@ func TestDOCXParser_TruncatedOLENotFallback(t *testing.T) {}}-// TestDOCXParser_OOXMLStillDOCX is the regression guard: a real OOXML-// (ZIP) payload must still take the "docx" path and parse successfully.-func TestDOCXParser_OOXMLStillDOCX(t *testing.T) {- ctx := t.Context()- p := NewDOCXParser()- data := minimalDOCX(t, "round-trip OOXML")- res := p.ParseWithResult(ctx, "real.docx", data)- if res.Err != nil {- t.Fatalf("ParseWithResult: %v", res.Err)- }- if res.OutputFormat != "markdown" {- t.Fatalf("OutputFormat = %q, want %q", res.OutputFormat, "markdown")- }- if got := res.File["format"]; got != "docx" {- t.Fatalf("File[format] = %v, want %q", got, "docx")- }- if !bytes.Contains([]byte(res.Markdown), []byte("round-trip OOXML")) {- t.Fatalf("Markdown = %q, want it to contain the source text", res.Markdown)- }-}-// TestPPTXParser_FallsBackToPPTForOLEHeader ensures a legacy OLE .ppt// payload routed to PPTXParser is opened with "ppt" rather than "pptx".func TestPPTXParser_FallsBackToPPTForOLEHeader(t *testing.T) {ctx := t.Context()p := NewPPTXParser()- orig := pptxOpenFromBytes- defer func() { pptxOpenFromBytes = orig }()+ orig := pptxExtract+ defer func() { pptxExtract = orig }()var gotFormat string- pptxOpenFromBytes = func(data []byte, format string) (*officeOxide.Document, error) {+ pptxExtract = func(data []byte, format string) (string, string, string, error, error) {gotFormat = format- return nil, fmt.Errorf("stub ppt open: %s", format)+ return "", "", "", nil, fmt.Errorf("stub ppt open: %s", format)}data := []byte{0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1}@@ -138,7 +182,7 @@ func TestPPTXParser_FallsBackToPPTForOLEHeader(t *testing.T) {t.Fatal("expected parse error for OLE header, got nil")}if gotFormat != "ppt" {- t.Fatalf("pptxOpenFromBytes format = %q, want %q", gotFormat, "ppt")+ t.Fatalf("pptxExtract format = %q, want %q", gotFormat, "ppt")}if p.format != "pptx" {t.Fatalf("PPTXParser.format mutated to %q, want %q (must use local effFormat)", p.format, "pptx")@@ -152,13 +196,13 @@ func TestPPTParser_FallsBackToPPTXForOOXMLHeader(t *testing.T) {ctx := t.Context()p := NewPPTParser() // underlying PPTXParser{format:"ppt"}- orig := pptxOpenFromBytes- defer func() { pptxOpenFromBytes = orig }()+ orig := pptxExtract+ defer func() { pptxExtract = orig }()var gotFormat string- pptxOpenFromBytes = func(data []byte, format string) (*officeOxide.Document, error) {+ pptxExtract = func(data []byte, format string) (string, string, string, error, error) {gotFormat = format- return nil, fmt.Errorf("stub ppt open: %s", format)+ return "", "", "", nil, fmt.Errorf("stub ppt open: %s", format)}// Minimal OOXML ZIP local file header.@@ -168,7 +212,7 @@ func TestPPTParser_FallsBackToPPTXForOOXMLHeader(t *testing.T) {t.Fatal("expected parse error for OOXML header stub, got nil")}if gotFormat != "pptx" {- t.Fatalf("pptxOpenFromBytes format = %q, want %q (OOXML fallback ppt->pptx)", gotFormat, "pptx")+ t.Fatalf("pptxExtract format = %q, want %q (OOXML fallback ppt->pptx)", gotFormat, "pptx")}// Underlying PPTXParser must not be mutated permanently.if p.pptx.format != "ppt" {@@ -183,13 +227,13 @@ func TestPPTXParser_NoStatePollution(t *testing.T) {ctx := t.Context()p := NewPPTXParser()- orig := pptxOpenFromBytes- defer func() { pptxOpenFromBytes = orig }()+ orig := pptxExtract+ defer func() { pptxExtract = orig }()calls := []string{}- pptxOpenFromBytes = func(data []byte, format string) (*officeOxide.Document, error) {+ pptxExtract = func(data []byte, format string) (string, string, string, error, error) {calls = append(calls, format)- return nil, fmt.Errorf("stub")+ return "", "", "", nil, fmt.Errorf("stub")}oleData := []byte{0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1}@@ -207,18 +251,3 @@ func TestPPTXParser_NoStatePollution(t *testing.T) {t.Errorf("second call format = %q, want %q (state polluted)", calls[1], "pptx")}}--// TestPPTXParser_OOXMLStillPPTX validates the effective format and File-// metadata for a real OOXML presentation.-func TestPPTXParser_OOXMLStillPPTX(t *testing.T) {- ctx := t.Context()- p := NewPPTXParser()- data := buildPPTX(t, "pptx round-trip")- res := p.ParseWithResult(ctx, "real.pptx", data)- if res.Err != nil {- t.Fatalf("ParseWithResult: %v", res.Err)- }- if got := res.File["format"]; got != "pptx" {- t.Fatalf("File[format] = %v, want %q", got, "pptx")- }-}diff --git a/internal/parser/parser/office_parsers.go b/internal/parser/parser/office_parsers.gonew file mode 100644index 0000000000..fa5b8ac149--- /dev/null+++ b/internal/parser/parser/office_parsers.go@@ -0,0 +1,11 @@+package parser++import "errors"++// ErrOfficeCGORequired is returned by the office-family parsers+// (DOC/DOCX/PPT/PPTX) when the build has no native office_oxide backend.+// The native engine (internal/deepdoc/parser/office) reports its own+// ErrOfficeCGORequired sentinel, which the facade wraps into this one so+// callers see a stable, parser-package error regardless of which layer+// reports the missing engine.+var ErrOfficeCGORequired = errors.New("parser: office family requires CGO (office_oxide)")diff --git a/internal/parser/parser/office_parsers_no_cgo.go b/internal/parser/parser/office_parsers_no_cgo.godeleted file mode 100644index b00d0c6f60..0000000000--- a/internal/parser/parser/office_parsers_no_cgo.go+++ /dev/null@@ -1,87 +0,0 @@-//go:build !cgo--package parser--import (- "context"- "errors"- "fmt"-)--// ErrOfficeCGORequired is returned by ParseWithResult on every-// office-parser family (DOC / DOCX / PPT / PPTX)-// when the build is not CGO-enabled. The CGO build's-// implementation captures the office_oxide PlainText / ToMarkdown-// output; this stub mirrors that surface so the package compiles-// and existing tests pass. The error is surfaced at parse time-// rather than at construction time, matching the NewPDFParser-// shape used by the rest of the package.-var ErrOfficeCGORequired = errors.New("parser: office family requires CGO (office_oxide)")--func (p *DOCXParser) ParseWithResult(_ context.Context, filename string, _ []byte) ParseResult {- return ParseResult{- File: map[string]any{"name": filename},- Err: fmt.Errorf("%w: docx", ErrOfficeCGORequired),- }-}--func (p *DOCParser) ParseWithResult(_ context.Context, filename string, _ []byte) ParseResult {- return ParseResult{- File: map[string]any{"name": filename},- Err: fmt.Errorf("%w: doc", ErrOfficeCGORequired),- }-}--func (p *PPTParser) ParseWithResult(_ context.Context, filename string, _ []byte) ParseResult {- return ParseResult{- File: map[string]any{"name": filename},- Err: fmt.Errorf("%w: ppt", ErrOfficeCGORequired),- }-}--func (p *PPTXParser) ParseWithResult(_ context.Context, filename string, _ []byte) ParseResult {- return ParseResult{- File: map[string]any{"name": filename},- Err: fmt.Errorf("%w: pptx", ErrOfficeCGORequired),- }-}--type DOCParser struct{}--func NewDOCParser() *DOCParser {- return &DOCParser{}-}--func (p *DOCParser) String() string {- return "DOCParser(no-cgo)"-}--type DOCXParser struct{}--func NewDOCXParser() *DOCXParser {- return &DOCXParser{}-}--func (p *DOCXParser) String() string {- return "DOCXParser(no-cgo)"-}--type PPTParser struct{}--func NewPPTParser() *PPTParser {- return &PPTParser{}-}--func (p *PPTParser) String() string {- return "PPTParser(no-cgo)"-}--type PPTXParser struct{}--func NewPPTXParser() *PPTXParser {- return &PPTXParser{}-}--func (p *PPTXParser) String() string {- return "PPTXParser(no-cgo)"-}diff --git a/internal/parser/parser/office_parsers_shared.go b/internal/parser/parser/office_parsers_shared.godeleted file mode 100644index 3f9e957761..0000000000--- a/internal/parser/parser/office_parsers_shared.go+++ /dev/null@@ -1,6 +0,0 @@-//go:build !cgo--package parser--// OfficeOxide is the lib_type identifier for office_oxide backend.-const OfficeOxide = "office_oxide"diff --git a/internal/parser/parser/pdf_parser_cgo.go b/internal/parser/parser/pdf_parser_cgo.godeleted file mode 100644index 959b275484..0000000000--- a/internal/parser/parser/pdf_parser_cgo.go+++ /dev/null@@ -1,55 +0,0 @@-//go:build cgo--package parser--import (- "context"- "errors"- "fmt"- "ragflow/internal/common"-- deepdocpdf "ragflow/internal/deepdoc/parser/pdf"- deepdoctype "ragflow/internal/deepdoc/parser/type"-)--func (p *PDFParser) ParseWithResult(ctx context.Context, filename string, data []byte) ParseResult {- if err := p.validateParseMethod(); err != nil {- return ParseResult{Err: err}- }- common.Info(fmt.Sprintf("------------file: %s, parse_method: %s", filename, p.ParseMethod))- switch normalizePDFParseMethod(p.ParseMethod) {- case "plain_text":- return parsePDFWithPlainText(filename, data, p)- case "mineru":- return parsePDFWithMinerU(ctx, filename, data, p)- case "paddleocr":- return parsePDFWithPaddleOCR(ctx, filename, data, p)- case "docling":- return parsePDFWithDocling(ctx, filename, data, p)- case "opendataloader":- return parsePDFWithOpenDataLoader(ctx, filename, data, p)- case "somark":- return parsePDFWithSoMark(filename, data, p)- case "tcadp":- return parsePDFWithTCADP(filename, data, p)- }- cfg := deepdoctype.DefaultParserConfig()- cfg.Pages = p.Pages- cfg.RemoveTOC = p.RemoveTOC- cfg.RemoveHeaderFooter = p.RemoveHeaderFooter- cfg.OnPageDone = p.OnPageDone- parser := deepdocpdf.NewParser(cfg)- res := parsePDFWithDeepDocOptions(ctx, filename, data, pdfPostProcessOptions{- outputFormat: p.OutputFormat,- zoom: cfg.Zoom,- enableMultiColumn: p.EnableMultiColumn,- flattenMediaToText: p.FlattenMediaToText,- }, parser.Parse)- if res.Err != nil && errors.Is(res.Err, deepdocpdf.ErrNoPDFData) {- return ParseResult{Err: fmt.Errorf("%w: %s", ErrPDFEngineUnavailable, filename)}- }- if res.Err != nil && res.Err.Error() == "deepdoc/pdf: cgo required" {- return ParseResult{Err: fmt.Errorf("%w: %s", ErrPDFEngineUnavailable, filename)}- }- return res-}diff --git a/internal/parser/parser/pdf_parser_common.go b/internal/parser/parser/pdf_parser_common.goindex f421c04888..f5e4201c07 100644--- a/internal/parser/parser/pdf_parser_common.go+++ b/internal/parser/parser/pdf_parser_common.go@@ -334,6 +334,61 @@ func (p *PDFParser) validateParseMethod() error {return fmt.Errorf("parser: unsupported PDF parse_method %q (Go currently supports: deepdoc, plain_text, mineru, paddleocr, docling, opendataloader, somark, tcadp; tenant-resolved custom IMAGE2TEXT/VLM model names are not supported in the Go parser layer)", p.ParseMethod)}+// ParseWithResult parses a PDF into a ParseResult, dispatching on the+// configured ParseMethod. The native extraction — the deepdoc default and the+// plain_text strategy — lives in the internal/deepdoc/parser/pdf engine; this+// method is the facade that wires strategies and post-processing. It is+// build-tag agnostic: under !cgo the deepdoc path transparently reports+// ErrPDFEngineUnavailable while plain_text falls back to the pure-Go engine.+func (p *PDFParser) ParseWithResult(ctx context.Context, filename string, data []byte) ParseResult {+ if err := p.validateParseMethod(); err != nil {+ return ParseResult{Err: err}+ }+ common.Info(fmt.Sprintf("------------file: %s, parse_method: %s", filename, p.ParseMethod))+ switch normalizePDFParseMethod(p.ParseMethod) {+ case "plain_text":+ if len(data) == 0 {+ return emptyPDFResult(filename)+ }+ items, pageCount, err := deepdocpdf.PlainText(data)+ if err != nil {+ return ParseResult{Err: fmt.Errorf("parser: plain_text: %w", err)}+ }+ return pdfItemsToResult(filename, items, p.OutputFormat, pageCount)+ case "mineru":+ return parsePDFWithMinerU(ctx, filename, data, p)+ case "paddleocr":+ return parsePDFWithPaddleOCR(ctx, filename, data, p)+ case "docling":+ return parsePDFWithDocling(ctx, filename, data, p)+ case "opendataloader":+ return parsePDFWithOpenDataLoader(ctx, filename, data, p)+ case "somark":+ return parsePDFWithSoMark(filename, data, p)+ case "tcadp":+ return parsePDFWithTCADP(filename, data, p)+ }+ cfg := deepdoctype.DefaultParserConfig()+ cfg.Pages = p.Pages+ cfg.RemoveTOC = p.RemoveTOC+ cfg.RemoveHeaderFooter = p.RemoveHeaderFooter+ cfg.OnPageDone = p.OnPageDone+ res := parsePDFWithDeepDocOptions(ctx, filename, data, pdfPostProcessOptions{+ outputFormat: p.OutputFormat,+ zoom: cfg.Zoom,+ enableMultiColumn: p.EnableMultiColumn,+ flattenMediaToText: p.FlattenMediaToText,+ }, deepdocpdf.NewParser(cfg).Parse)+ if res.Err != nil {+ if errors.Is(res.Err, deepdocpdf.ErrNoPDFData) ||+ strings.Contains(res.Err.Error(), "deepdoc/pdf: cgo required") ||+ strings.Contains(res.Err.Error(), "no in-process DeepDoc backend") {+ return ParseResult{Err: fmt.Errorf("%w: %s", ErrPDFEngineUnavailable, filename)}+ }+ }+ return res+}+func emptyPDFResult(filename string) ParseResult {return ParseResult{OutputFormat: "json",diff --git a/internal/parser/parser/pdf_parser_nocgo.go b/internal/parser/parser/pdf_parser_nocgo.godeleted file mode 100644index ad3a67d0ec..0000000000--- a/internal/parser/parser/pdf_parser_nocgo.go+++ /dev/null@@ -1,36 +0,0 @@-//go:build !cgo--package parser--import (- "context"- "fmt"-)--func (p *PDFParser) ParseWithResult(ctx context.Context, filename string, data []byte) ParseResult {- if err := p.validateParseMethod(); err != nil {- return ParseResult{Err: err}- }- switch normalizePDFParseMethod(p.ParseMethod) {- case "plain_text":- return parsePDFWithPlainText(filename, data, p)- case "mineru":- return parsePDFWithMinerU(ctx, filename, data, p)- case "paddleocr":- return parsePDFWithPaddleOCR(ctx, filename, data, p)- case "docling":- return parsePDFWithDocling(ctx, filename, data, p)- case "opendataloader":- return parsePDFWithOpenDataLoader(ctx, filename, data, p)- case "somark":- return parsePDFWithSoMark(filename, data, p)- case "tcadp":- return parsePDFWithTCADP(filename, data, p)- }- if len(data) == 0 {- return emptyPDFResult(filename)- }- return ParseResult{- Err: fmt.Errorf("%w: %s", ErrPDFEngineUnavailable, filename),- }-}diff --git a/internal/parser/parser/pdf_parser_plaintext_cgo.go b/internal/parser/parser/pdf_parser_plaintext_cgo.godeleted file mode 100644index 52b2dfc5fa..0000000000--- a/internal/parser/parser/pdf_parser_plaintext_cgo.go+++ /dev/null@@ -1,38 +0,0 @@-//go:build cgo--package parser--import (- "fmt"-- "ragflow/internal/deepdoc/parser/pdf/pdfoxide"-)--func parsePDFWithPlainText(filename string, data []byte, parser *PDFParser) ParseResult {- if len(data) == 0 {- return emptyPDFResult(filename)- }- doc, err := pdfoxide.OpenBytes(data)- if err != nil {- return ParseResult{Err: fmt.Errorf("parser: plain_text open: %w", err)}- }- defer doc.Close()-- pageCount, err := doc.PageCount()- if err != nil {- return ParseResult{Err: fmt.Errorf("parser: plain_text page count: %w", err)}- }- items := make([]map[string]any, 0, pageCount)- for page := 0; page < pageCount; page++ {- text, err := doc.GetPageText(page)- if err != nil {- return ParseResult{Err: fmt.Errorf("parser: plain_text page %d: %w", page+1, err)}- }- items = append(items, map[string]any{- "text": text,- "doc_type_kwd": "text",- "page_number": page + 1,- })- }- return pdfItemsToResult(filename, items, parser.OutputFormat, pageCount)-}diff --git a/internal/parser/parser/pdf_parser_plaintext_nocgo.go b/internal/parser/parser/pdf_parser_plaintext_nocgo.godeleted file mode 100644index efbc991469..0000000000--- a/internal/parser/parser/pdf_parser_plaintext_nocgo.go+++ /dev/null@@ -1,42 +0,0 @@-//go:build !cgo--package parser--import (- "bytes"- "fmt"- "strings"-- "github.com/ledongthuc/pdf"-)--func parsePDFWithPlainText(filename string, data []byte, parser *PDFParser) ParseResult {- if len(data) == 0 {- return emptyPDFResult(filename)- }-- reader := bytes.NewReader(data)- pdfReader, err := pdf.NewReader(reader, int64(len(data)))- if err != nil {- return ParseResult{Err: fmt.Errorf("parser: plain_text open: %w", err)}- }-- pageCount := pdfReader.NumPage()- items := make([]map[string]any, 0, pageCount)- for pageNum := 1; pageNum <= pageCount; pageNum++ {- p := pdfReader.Page(pageNum)- if p.V.IsNull() {- continue- }- text, err := p.GetPlainText(nil)- if err != nil {- return ParseResult{Err: fmt.Errorf("parser: plain_text page %d: %w", pageNum, err)}- }- items = append(items, map[string]any{- "text": strings.TrimRight(text, "\n"),- "doc_type_kwd": "text",- "page_number": pageNum,- })- }- return pdfItemsToResult(filename, items, parser.OutputFormat, pageCount)-}diff --git a/internal/parser/parser/ppt_parser.go b/internal/parser/parser/ppt_parser.goindex d7e4b12a42..68658ee5ae 100644--- a/internal/parser/parser/ppt_parser.go+++ b/internal/parser/parser/ppt_parser.go@@ -1,5 +1,3 @@-//go:build cgo-//// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.//@@ -7,14 +5,13 @@// you may not use this file except in compliance with the License.// You may obtain a copy of the License at//-// http://www.apache.org/licenses/LICENSE-2.0+// http://www.apache.org/licenses/LICENSE-2.0//// Unless required by applicable law or agreed to in writing, software// distributed under the License is distributed on an "AS IS" BASIS,// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.// See the License for the specific language governing permissions and// limitations under the License.-//package parserdiff --git a/internal/parser/parser/pptx_parser.go b/internal/parser/parser/pptx_parser.goindex 8b7a6c9bb4..5a2420df7c 100644--- a/internal/parser/parser/pptx_parser.go+++ b/internal/parser/parser/pptx_parser.go@@ -1,5 +1,3 @@-//go:build cgo-//// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.//@@ -7,29 +5,29 @@// you may not use this file except in compliance with the License.// You may obtain a copy of the License at//-// http://www.apache.org/licenses/LICENSE-2.0+// http://www.apache.org/licenses/LICENSE-2.0//// Unless required by applicable law or agreed to in writing, software// distributed under the License is distributed on an "AS IS" BASIS,// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.// See the License for the specific language governing permissions and// limitations under the License.-//package parserimport ("context"+ "errors""fmt""strings"- officeOxide "github.com/yfedoseev/office_oxide/go"+ deepdocoffice "ragflow/internal/deepdoc/parser/office")-// pptxOpenFromBytes is a test seam mirroring officeOxide.OpenFromBytes.-// Not safe for concurrent use with t.Parallel() — tests must save/restore-// it sequentially.-var pptxOpenFromBytes = officeOxide.OpenFromBytes+// pptxExtract is a test seam for the native office_oxide extraction. It+// defaults to the deepdoc/docx backend and is overridden in tests to capture+// the effective container format passed to the engine.+var pptxExtract = deepdocoffice.OpenAndExtract// PPTXParser parses both .pptx (OOXML) and .ppt (OLE binary)// files via the office_oxide backend. The format field controls@@ -118,6 +116,7 @@ func (p *PPTXParser) ParseWithResult(ctx context.Context, filename string, data// PDF-specific methods like "paddleocr" / "mineru" are// meaningless for PPTX; treat as default path.}+// office_oxide's OpenFromBytes takes the container format as given// and does no magic-byte detection, so a legacy .ppt uploaded with a// .pptx extension would be parsed as ZIP/OOXML and fail. Sniff the@@ -138,30 +137,28 @@ func (p *PPTXParser) ParseWithResult(ctx context.Context, filename string, dataeffFormat = "pptx"}}- doc, err := pptxOpenFromBytes(data, effFormat)+ irJSON, _, plainText, _, err := pptxExtract(data, effFormat)if err != nil {- return ParseResult{Err: fmt.Errorf("presentation open: %w", err)}+ if errors.Is(err, deepdocoffice.ErrOfficeCGORequired) {+ return ParseResult{Err: fmt.Errorf("%w: %s", ErrOfficeCGORequired, filename)}+ }+ return ParseResult{Err: fmt.Errorf("presentation extract: %w", err)}}- defer doc.Close()// office_oxide's PlainText renders slides back-to-back with no page// delimiter, so per-slide splitting must go through the structured- // IR, which carries one section per slide.- irJSON, err := doc.ToIRJSON()- if err != nil {- // Salvage path: the document opened but its structured IR could- // not be serialized. Fall back to whole-document plain text- // (worst case: the entire deck as one chunk) so a still-readable- // deck yields content instead of a hard parse error. The original- // IR error is surfaced only when plain text fails too.- text, perr := doc.PlainText()- if perr != nil {- return ParseResult{Err: fmt.Errorf("presentation ir-json: %w", err)}+ // IR, which carries one section per slide. When the IR is empty, fall+ // back to whole-document plain text (worst case: the entire deck as one+ // chunk) so a still-readable deck yields content instead of a hard+ // parse error.+ if strings.TrimSpace(irJSON) == "" {+ if strings.TrimSpace(plainText) == "" {+ return ParseResult{Err: fmt.Errorf("presentation ir-json: empty result")}}return ParseResult{OutputFormat: "json",- File: map[string]any{"name": filename, "format": p.format},- JSON: itemsFromPlainText(text),+ File: map[string]any{"name": filename, "format": effFormat},+ JSON: itemsFromPlainText(plainText),}}budget := newEmbeddedMediaBudget()@@ -179,11 +176,9 @@ func (p *PPTXParser) ParseWithResult(ctx context.Context, filename string, data// still-readable file yields content instead of none. Without// the all-empty check, empty items flow to the Tokenizer, which// filters them as empty text, silently yielding 0 chunks.- text, perr := doc.PlainText()- if perr != nil {- return ParseResult{Err: fmt.Errorf("presentation plain-text: %w", perr)}+ if strings.TrimSpace(plainText) != "" {+ items = itemsFromPlainText(plainText)}- items = itemsFromPlainText(text)}return ParseResult{diff --git a/test/playwright/conftest.py b/test/playwright/conftest.pyindex c2e3707127..e3bcbbdd67 100644--- a/test/playwright/conftest.py+++ b/test/playwright/conftest.py@@ -113,7 +113,7 @@ def _playwright_auth_ready_timeout_ms() -> int | None:def _playwright_hang_timeout_s() -> int:raw = _env_int_with_fallback("PLAYWRIGHT_HANG_TIMEOUT_S", "HANG_TIMEOUT_S", DEFAULT_HANG_TIMEOUT_S)- return raw if raw > 0 else 0+ return max(0, raw)def _failure_text(req) -> str:@@ -400,8 +400,8 @@ def _rsa_encrypt_password(password: str) -> str:global _PUBLIC_KEY_CACHEglobal _RSA_CIPHER_CACHEtry:- from Cryptodome.PublicKey import RSAfrom Cryptodome.Cipher import PKCS1_v1_5 as Cipher_pkcs1_v1_5+ from Cryptodome.PublicKey import RSAexcept Exception as exc:raise RuntimeError("Cryptodome is required to encrypt passwords for API seeding. Set RAGFLOW_SEEDING_MODE=ui to skip API seeding.") from excif _PUBLIC_KEY_CACHE is None:diff --git a/test/testcases/configs.py b/test/testcases/configs.pyindex b8331d979b..65b71ef5b9 100644--- a/test/testcases/configs.py+++ b/test/testcases/configs.py@@ -19,7 +19,6 @@ from pathlib import Pathimport pytest-_DOCKER_ENV = Path(__file__).resolve().parents[2] / "docker" / ".env"diff --git a/test/testcases/restful_api/test_agents_go_mode.py b/test/testcases/restful_api/test_agents_go_mode.pyindex 6ec00245dd..175f300ab4 100644--- a/test/testcases/restful_api/test_agents_go_mode.py+++ b/test/testcases/restful_api/test_agents_go_mode.py@@ -1,5 +1,6 @@import osimport uuid+import pytestpytestmark = pytest.mark.skipif(diff --git a/test/testcases/restful_api/test_chats.py b/test/testcases/restful_api/test_chats.pyindex 6c14b76566..47cf7a1731 100644--- a/test/testcases/restful_api/test_chats.py+++ b/test/testcases/restful_api/test_chats.py@@ -18,8 +18,8 @@ import asyncioimport importlib.utilimport reimport sys-from copy import deepcopyfrom concurrent.futures import ThreadPoolExecutor+from copy import deepcopyfrom enum import Enumfrom functools import wrapsfrom pathlib import Path@@ -33,7 +33,6 @@ from test.testcases.restful_api.helpers.client import RestClientfrom test.testcases.utils import encode_avatarfrom test.testcases.utils.file_utils import create_image_file-DEFAULT_CHAT_EMPTY_RESPONSE = "Sorry! No relevant content was found in the knowledge base!"DEFAULT_CHAT_PROLOGUE = "Hi! I'm your assistant. What can I do for you?"DEFAULT_CHAT_SYSTEM_PROMPT = (@@ -628,7 +627,8 @@ def _load_chat_routes_unit_module(monkeypatch):common_constants_mod.LLMType = _StubLLMTypecommon_constants_mod.RetCode = _StubRetCodecommon_constants_mod.StatusEnum = _StubStatusEnum- from common.constants import MAXIMUM_PAGE_NUMBER as _MPN, MAXIMUM_TASK_PAGE_NUMBER as _MTPN+ from common.constants import MAXIMUM_PAGE_NUMBER as _MPN+ from common.constants import MAXIMUM_TASK_PAGE_NUMBER as _MTPNcommon_constants_mod.MAXIMUM_PAGE_NUMBER = _MPNcommon_constants_mod.MAXIMUM_TASK_PAGE_NUMBER = _MTPNdiff --git a/test/testcases/restful_api/test_search_datasets_consistency.py b/test/testcases/restful_api/test_search_datasets_consistency.pyindex 4e47d5449c..3837e777e3 100644--- a/test/testcases/restful_api/test_search_datasets_consistency.py+++ b/test/testcases/restful_api/test_search_datasets_consistency.py@@ -35,12 +35,13 @@ runs against the pre-built data. Cleanup happens automatically at module teardowimport loggingimport osimport sys-import pytest-import requestsimport tempfileimport timeimport uuid+import pytest+import requests+# Logging setup# Default is silent. Set LOG_LEVEL=INFO locally to see logger.info() messages._LOG_LEVEL = os.environ.get("LOG_LEVEL", "WARNING").upper()