إدارة معالجات الذكاء الاصطناعي للمستندات باستخدام Python

إدارة معالجات Document AI باستخدام لغة Python

الدقائق المتبقية: 11

إدارة معالجات Document AI باستخدام لغة Python

لمحة عن هذا الدرس التطبيقي حول الترميز

تاريخ التعديل الأخير: مايو 13, 2025

تأليف: Laurent Picard

1. نظرة عامة

ما هو Document AI؟

‫Document AI هي منصّة تتيح لك استخراج إحصاءات من مستنداتك. ويقدّم هذا الإطار بشكل أساسي قائمة متزايدة من معالجات المستندات (المعروفة أيضًا باسم "المحلّلات" أو "المقسّمات"، حسب وظائفها).

هناك طريقتان لإدارة وحدات معالجة Document AI:

يدويًا، من وحدة تحكّم الويب
آليًا باستخدام واجهة برمجة التطبيقات Document AI API

في ما يلي مثال على لقطة شاشة تعرض قائمة المعالجات، سواء من وحدة تحكّم الويب أو من رمز Python البرمجي:

في هذا التمرين المعملي، ستركز على إدارة معالجات "تكنولوجيات الذكاء الاصطناعي للوثائق" آليًا باستخدام مكتبة Python للعملاء.

البيانات التي ستظهر لك

كيفية إعداد بيئتك
كيفية جلب أنواع المعالجات
كيفية إنشاء وحدات معالجة
كيفية إدراج معالجات المشاريع
كيفية استخدام المعالجات
كيفية تفعيل/إيقاف المعالجات
كيفية إدارة إصدارات المعالج
كيفية حذف المعالجات

المتطلبات

مشروع على Google Cloud
متصفّح، مثل Chrome أو Firefox
معرفة جيدة باستخدام لغة Python

الاستطلاع

كيف ستستخدم هذا الدليل التعليمي؟

قراءته فقطقراءته وإكمال التمارين

كيف تقيّم تجربتك مع Python؟

مبتدئمتوسطمتقدّم

ما هو تقييمك لتجربتك مع خدمات Google Cloud؟

مبتدئمتوسطمتقدّم

إعداد البيئة حسب السرعة التي تناسبك

سجِّل الدخول إلى Google Cloud Console وأنشئ مشروعًا جديدًا أو أعِد استخدام مشروع حالي. إذا لم يكن لديك حساب على Gmail أو Google Workspace، عليك إنشاء حساب.

اسم المشروع هو الاسم المعروض للمشاركين في هذا المشروع. وهي سلسلة أحرف لا تستخدمها واجهات برمجة تطبيقات Google. ويمكنك تعديلها في أي وقت.
يكون معرّف المشروع فريدًا في جميع مشاريع Google Cloud وغير قابل للتغيير (لا يمكن تغييره بعد ضبطه). تنشئ وحدة تحكّم Cloud Console سلسلة فريدة تلقائيًا، ولا يهمّك عادةً معرفة محتواها. في معظم مختبرات رموز البرامج، ستحتاج إلى الإشارة إلى معرّف المشروع (يُعرَف عادةً باسم PROJECT_ID). إذا لم يعجبك المعرّف الذي تم إنشاؤه، يمكنك إنشاء معرّف آخر عشوائي. يمكنك بدلاً من ذلك تجربة عنوانك الخاص لمعرفة ما إذا كان متاحًا. ولا يمكن تغييره بعد هذه الخطوة ويبقى ساريًا طوال مدة المشروع.
يُرجى العِلم أنّ هناك قيمة ثالثة، وهي رقم المشروع، تستخدمها بعض واجهات برمجة التطبيقات. يمكنك الاطّلاع على مزيد من المعلومات عن كلّ من هذه القيم الثلاث في المستندات.

بعد ذلك، عليك تفعيل الفوترة في Cloud Console لاستخدام موارد/واجهات برمجة تطبيقات Cloud. لن تتطلّب المشاركة في هذا الدليل التعليمي البرمجي أي تكلفة، أو قد تتطلّب تكلفة بسيطة. لإيقاف الموارد لتجنُّب تحصيل رسوم بعد انتهاء هذا الدليل التعليمي، يمكنك حذف الموارد التي أنشأتها أو حذف المشروع. يكون مستخدمو Google Cloud الجدد مؤهّلين للاستفادة من برنامج الفترة التجريبية المجانية التي تبلغ قيمتها 300 دولار أمريكي.

بدء Cloud Shell

على الرغم من أنّه يمكن تشغيل Google Cloud عن بُعد من الكمبيوتر المحمول، ستستخدم في هذا البرنامج التعليمي Cloud Shell، وهي بيئة سطر أوامر تعمل في السحابة الإلكترونية.

تفعيل Cloud Shell

من Cloud Console، انقر على تفعيل Cloud Shell .

إذا كانت هذه هي المرة الأولى التي تبدأ فيها Cloud Shell، ستظهر لك شاشة وسيطة توضّح ماهية هذه الخدمة. إذا ظهرت لك شاشة وسيطة، انقر على متابعة.

من المفترض ألا يستغرق توفير Cloud Shell والاتصال بها سوى بضع لحظات.

تم تحميل هذه الآلة الافتراضية بجميع أدوات التطوير اللازمة. ويقدّم هذا الدليل دليلاً منزليًا دائمًا بسعة 5 غيغابايت ويتم تشغيله في Google Cloud، ما يُحسِّن بشكل كبير أداء الشبكة والمصادقة. يمكن تنفيذ الكثير من عملك في هذا الدليل التعليمي للترميز، إن لم يكن كلّه، باستخدام متصفّح.

بعد الاتصال بخدمة Cloud Shell، من المفترض أن تظهر لك رسالة تفيد بأنّه تم مصادقة حسابك وأنّه تم ضبط المشروع على معرّف مشروعك.

نفِّذ الأمر التالي في Cloud Shell لتأكيد مصادقة حسابك:

gcloud auth list

ناتج الأمر

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

شغِّل الأمر التالي في Cloud Shell للتأكّد من أنّ الأمر gcloud يعرف مشروعك:

gcloud config list project

ناتج الأمر

[core]
project = <PROJECT_ID>

إذا لم يكن كذلك، يمكنك تعيينه من خلال هذا الأمر:

gcloud config set project <PROJECT_ID>

ناتج الأمر

Updated property [core/project].

3. إعداد البيئة

قبل أن تتمكّن من بدء استخدام Document AI، عليك تنفيذ الأمر التالي في Cloud Shell لتفعيل واجهة برمجة التطبيقات Document AI API:

gcloud services enable documentai.googleapis.com

ينبغي أن تظهر لك على النحو التالي:

Operation "operations/..." finished successfully.

يمكنك الآن استخدام Document AI.

انتقِل إلى الدليل الرئيسي:

cd ~

أنشئ بيئة افتراضية لبرنامج Python لعزل التبعيات:

virtualenv venv-docai

فعِّل البيئة الافتراضية:

source venv-docai/bin/activate

ثبِّت IPython ومكتبة عملاء Document AI وpython-tabulate (التي ستستخدمها لطباعة نتائج الطلب بشكل جميل):

pip install ipython google-cloud-documentai tabulate

ينبغي أن تظهر لك على النحو التالي:

...
Installing collected packages: ..., tabulate, ipython, google-cloud-documentai
Successfully installed ... google-cloud-documentai-2.15.0 ...

يمكنك الآن استخدام مكتبة عملاء Document AI.

اضبط متغيّرات البيئة التالية:

export PROJECT_ID=$(gcloud config get-value core/project)

# Choose "us" or "eu"
export API_LOCATION="us"

من الآن فصاعدًا، من المفترض أن تكتمل جميع الخطوات في الجلسة نفسها.

تأكَّد من تحديد متغيّرات البيئة بشكلٍ صحيح:

echo $PROJECT_ID

echo $API_LOCATION

في الخطوات التالية، ستستخدم مترجمًا تفاعليًا لبرنامج Python يُسمى IPython، والذي تم تثبيته للتو. ابدأ جلسة من خلال تشغيل ipython في Cloud Shell:

ipython

ينبغي أن تظهر لك على النحو التالي:

Python 3.12.3 (main, Feb  4 2025, 14:48:35) [GCC 13.3.0]
Type 'copyright', 'credits' or 'license' for more information
IPython 9.1.0 -- An enhanced Interactive Python. Type '?' for help.

In [1]:

انسخ الرمز التالي إلى جلسة IPython:

import os
from typing import Iterator, MutableSequence, Optional, Sequence, Tuple

import google.cloud.documentai_v1 as docai
from tabulate import tabulate

PROJECT_ID = os.getenv("PROJECT_ID", "")
API_LOCATION = os.getenv("API_LOCATION", "")

assert PROJECT_ID, "PROJECT_ID is undefined"
assert API_LOCATION in ("us", "eu"), "API_LOCATION is incorrect"

# Test processors
document_ocr_display_name = "document-ocr"
form_parser_display_name = "form-parser"

test_processor_display_names_and_types = (
    (document_ocr_display_name, "OCR_PROCESSOR"),
    (form_parser_display_name, "FORM_PARSER_PROCESSOR"),
)

def get_client() -> docai.DocumentProcessorServiceClient:
    client_options = {"api_endpoint": f"{API_LOCATION}-documentai.googleapis.com"}
    return docai.DocumentProcessorServiceClient(client_options=client_options)

def get_parent(client: docai.DocumentProcessorServiceClient) -> str:
    return client.common_location_path(PROJECT_ID, API_LOCATION)

def get_client_and_parent() -> Tuple[docai.DocumentProcessorServiceClient, str]:
    client = get_client()
    parent = get_parent(client)
    return client, parent

لقد أصبحت مستعدًا لتقديم طلبك الأول واسترداد أنواع المعالجات.

4. جلب أنواع المعالج

قبل إنشاء معالج في الخطوة التالية، يمكنك جلب أنواع المعالجات المتاحة. يمكنك استرداد هذه القائمة باستخدام fetch_processor_types.

أضِف الدوالّ التالية إلى جلسة IPython:

def fetch_processor_types() -> MutableSequence[docai.ProcessorType]:
    client, parent = get_client_and_parent()
    response = client.fetch_processor_types(parent=parent)

    return response.processor_types

def print_processor_types(processor_types: Sequence[docai.ProcessorType]):
    def sort_key(pt):
        return (not pt.allow_creation, pt.category, pt.type_)

    sorted_processor_types = sorted(processor_types, key=sort_key)
    data = processor_type_tabular_data(sorted_processor_types)
    headers = next(data)
    colalign = next(data)

    print(tabulate(data, headers, tablefmt="pretty", colalign=colalign))
    print(f"→ Processor types: {len(sorted_processor_types)}")

def processor_type_tabular_data(
    processor_types: Sequence[docai.ProcessorType],
) -> Iterator[Tuple[str, str, str, str]]:
    def locations(pt):
        return ", ".join(sorted(loc.location_id for loc in pt.available_locations))

    yield ("type", "category", "allow_creation", "locations")
    yield ("left", "left", "left", "left")
    if not processor_types:
        yield ("-", "-", "-", "-")
        return
    for pt in processor_types:
        yield (pt.type_, pt.category, f"{pt.allow_creation}", locations(pt))

أدخِل أنواع المعالجات:

processor_types = fetch_processor_types()
print_processor_types(processor_types)

من المفترض أن يظهر لك ما يلي:

+--------------------------------------+-------------+----------------+-----------+
| type                                 | category    | allow_creation | locations |
+--------------------------------------+-------------+----------------+-----------+
| CUSTOM_CLASSIFICATION_PROCESSOR      | CUSTOM      | True           | eu, us    |
...
| FORM_PARSER_PROCESSOR                | GENERAL     | True           | eu, us    |
| LAYOUT_PARSER_PROCESSOR              | GENERAL     | True           | eu, us    |
| OCR_PROCESSOR                        | GENERAL     | True           | eu, us    |
| BANK_STATEMENT_PROCESSOR             | SPECIALIZED | True           | eu, us    |
| EXPENSE_PROCESSOR                    | SPECIALIZED | True           | eu, us    |
...
+--------------------------------------+-------------+----------------+-----------+
→ Processor types: 19

لديك الآن كل المعلومات اللازمة لإنشاء معالجات في الخطوة التالية.

5. إنشاء وحدات المعالجة

لإنشاء وحدة معالجة، اتصل بـ create_processor مع الاسم المعروض ونوع وحدة المعالجة.

أضِف الدالة التالية:

def create_processor(display_name: str, type: str) -> docai.Processor:
    client, parent = get_client_and_parent()
    processor = docai.Processor(display_name=display_name, type_=type)

    return client.create_processor(parent=parent, processor=processor)

أنشئ معالجات الاختبار:

separator = "=" * 80
for display_name, type in test_processor_display_names_and_types:
    print(separator)
    print(f"Creating {display_name} ({type})...")
    try:
        create_processor(display_name, type)
    except Exception as err:
        print(err)
print(separator)
print("Done")

من المفترض أن تظهر لك المعلومات التالية:

================================================================================
Creating document-ocr (OCR_PROCESSOR)...
================================================================================
Creating form-parser (FORM_PARSER_PROCESSOR)...
================================================================================
Done

لقد أنشأت معالجات جديدة.

بعد ذلك، اطّلِع على كيفية إدراج المعالجات.

6. إدراج معالجات المشاريع

list_processors تعرِض قائمة بجميع المعالجات التي تنتمي إلى مشروعك.

أضِف الدوالّ التالية:

def list_processors() -> MutableSequence[docai.Processor]:
    client, parent = get_client_and_parent()
    response = client.list_processors(parent=parent)

    return list(response.processors)

def print_processors(processors: Optional[Sequence[docai.Processor]] = None):
    def sort_key(processor):
        return processor.display_name

    if processors is None:
        processors = list_processors()
    sorted_processors = sorted(processors, key=sort_key)
    data = processor_tabular_data(sorted_processors)
    headers = next(data)
    colalign = next(data)

    print(tabulate(data, headers, tablefmt="pretty", colalign=colalign))
    print(f"→ Processors: {len(sorted_processors)}")

def processor_tabular_data(
    processors: Sequence[docai.Processor],
) -> Iterator[Tuple[str, str, str]]:
    yield ("display_name", "type", "state")
    yield ("left", "left", "left")
    if not processors:
        yield ("-", "-", "-")
        return
    for processor in processors:
        yield (processor.display_name, processor.type_, processor.state.name)

استدعاء الدوالّ:

processors = list_processors()
print_processors(processors)

من المفترض أن تظهر لك المعلومات التالية:

+--------------+-----------------------+---------+
| display_name | type                  | state   |
+--------------+-----------------------+---------+
| document-ocr | OCR_PROCESSOR         | ENABLED |
| form-parser  | FORM_PARSER_PROCESSOR | ENABLED |
+--------------+-----------------------+---------+
→ Processors: 2

لاسترداد وحدة معالجة ضوئية حسب اسمها المعروض، أضِف الدالة التالية:

def get_processor(
    display_name: str,
    processors: Optional[Sequence[docai.Processor]] = None,
) -> Optional[docai.Processor]:
    if processors is None:
        processors = list_processors()
    for processor in processors:
        if processor.display_name == display_name:
            return processor
    return None

اختبِر الدالة:

processor = get_processor(document_ocr_display_name, processors)

assert processor is not None
print(processor)

ينبغي أن تظهر لك على النحو التالي:

name: "projects/PROJECT_NUM/locations/LOCATION/processors/PROCESSOR_ID"
type_: "OCR_PROCESSOR"
display_name: "document-ocr"
state: ENABLED
...

الآن، لديك المعلومات اللازمة لمعرفة كيفية إدراج معالجات المشاريع واستردادها حسب أسمائها المعروضة. بعد ذلك، اطّلِع على كيفية استخدام وحدة معالجة.

7. استخدام المعالجات

يمكن معالجة المستندات بطريقتَين:

بشكل متزامن: يمكنك استدعاء process_document لتحليل مستند واحد واستخدام النتائج مباشرةً.
بشكل غير متزامن: يمكنك الاتصال بالرقم batch_process_documents لبدء معالجة مجمّعة لمستندات متعددة أو كبيرة.

المستند التجريبي ( بتنسيق PDF) هو استبيان ممسوح ضوئيًا مكتمل بالإجابات المكتوبة بخط اليد. نزِّله إلى دليل العمل مباشرةً من جلسة IPython:

!gsutil cp gs://cloud-samples-data/documentai/form.pdf .

تحقّق من محتوى دليل العمل:

!ls

يجب توفّر ما يلي:

...  form.pdf  ...  venv-docai  ...

يمكنك استخدام الطريقة المتزامنة process_document لتحليل ملف محلي. أضِف الدالة التالية:

def process_file(
    processor: docai.Processor,
    file_path: str,
    mime_type: str,
) -> docai.Document:
    client = get_client()
    with open(file_path, "rb") as document_file:
        document_content = document_file.read()
    document = docai.RawDocument(content=document_content, mime_type=mime_type)
    request = docai.ProcessRequest(raw_document=document, name=processor.name)

    response = client.process_document(request)

    return response.document

بما أنّ المستند عبارة عن استبيان، اختَر أداة تحليل النماذج. بالإضافة إلى استخراج النص (المكتوب والمطبوع)، وهو ما تُجريه جميع المعالجات، يرصد هذا المعالج العام حقول النماذج.

تحليل المستند:

processor = get_processor(form_parser_display_name)
assert processor is not None

file_path = "./form.pdf"
mime_type = "application/pdf"

document = process_file(processor, file_path, mime_type)

تُجري جميع المعالجات عملية أولى للتعرّف البصري على الأحرف (OCR) على المستند. راجِع النص الذي تم رصده من خلال خطوة التعرّف البصري على الأحرف:

document.text.split("\n")

من المفترض أن يظهر لك ما يلي:

['FakeDoc M.D.',
 'HEALTH INTAKE FORM',
 'Please fill out the questionnaire carefully. The information you provide will be used to complete',
 'your health profile and will be kept confidential.',
 'Date:',
 '9/14/19',
 'Name:',
 'Sally Walker',
 'DOB: 09/04/1986',
 'Address: 24 Barney Lane',
 'City: Towaco',
 'State: NJ Zip: 07082',
 'Email: Sally, walker@cmail.com',
 '_Phone #: (906) 917-3486',
 'Gender: F',
 'Marital Status:',
  ...
]

أضِف الدوالّ التالية لطباعة حقول النماذج التي تم رصدها:

def print_form_fields(document: docai.Document):
    sorted_form_fields = form_fields_sorted_by_ocr_order(document)
    data = form_field_tabular_data(sorted_form_fields, document)
    headers = next(data)
    colalign = next(data)

    print(tabulate(data, headers, tablefmt="pretty", colalign=colalign))
    print(f"→ Form fields: {len(sorted_form_fields)}")

def form_field_tabular_data(
    form_fields: Sequence[docai.Document.Page.FormField],
    document: docai.Document,
) -> Iterator[Tuple[str, str, str]]:
    yield ("name", "value", "confidence")
    yield ("right", "left", "right")
    if not form_fields:
        yield ("-", "-", "-")
        return
    for form_field in form_fields:
        name_layout = form_field.field_name
        value_layout = form_field.field_value
        name = text_from_layout(name_layout, document)
        value = text_from_layout(value_layout, document)
        confidence = value_layout.confidence
        yield (name, value, f"{confidence:.1%}")

أضِف أيضًا دوالّ المرافق التالية:

def form_fields_sorted_by_ocr_order(
    document: docai.Document,
) -> MutableSequence[docai.Document.Page.FormField]:
    def sort_key(form_field):
        # Sort according to the field name detected position
        text_anchor = form_field.field_name.text_anchor
        return text_anchor.text_segments[0].start_index if text_anchor else 0

    fields = (field for page in document.pages for field in page.form_fields)

    return sorted(fields, key=sort_key)


def text_from_layout(
    layout: docai.Document.Page.Layout,
    document: docai.Document,
) -> str:
    full_text = document.text
    segs = layout.text_anchor.text_segments
    text = "".join(full_text[seg.start_index : seg.end_index] for seg in segs)
    if text.endswith("\n"):
        text = text[:-1]

    return text

اطبع حقول النموذج التي تم رصدها:

print_form_fields(document)

من المفترض أن تظهر لك نسخة مطبوعة بالشكل التالي:

+-----------------+-------------------------+------------+
|            name | value                   | confidence |
+-----------------+-------------------------+------------+
|           Date: | 9/14/19                 |      83.0% |
|           Name: | Sally Walker            |      87.3% |
|            DOB: | 09/04/1986              |      88.5% |
|        Address: | 24 Barney Lane          |      82.4% |
|           City: | Towaco                  |      90.0% |
|          State: | NJ                      |      89.4% |
|            Zip: | 07082                   |      91.4% |
|          Email: | Sally, walker@cmail.com |      79.7% |
|       _Phone #: | walker@cmail.com        |      93.2% |
|                 | (906                    |            |
|         Gender: | F                       |      88.2% |
| Marital Status: | Single                  |      85.2% |
|     Occupation: | Software Engineer       |      81.5% |
|    Referred By: | None                    |      76.9% |
...
+-----------------+-------------------------+------------+
→ Form fields: 17

راجِع أسماء الحقول والقيم التي تم رصدها ( PDF). في ما يلي النصف العلوي من الاستبيان:

إذا حلّلت نموذجًا يحتوي على نص مطبوع ونص مكتوب بخط اليد ورصدت أيضًا حقول هذا النموذج بثقة عالية. والنتيجة هي أنّه تم تحويل وحدات البكسل إلى بيانات منظَّمة.

8. تفعيل المعالجات وإيقافها

باستخدام disable_processor وenable_processor، يمكنك التحكّم في إمكانية استخدام وحدة معالجة.

أضِف الدوالّ التالية:

def update_processor_state(processor: docai.Processor, enable_processor: bool):
    client = get_client()
    if enable_processor:
        request = docai.EnableProcessorRequest(name=processor.name)
        operation = client.enable_processor(request)
    else:
        request = docai.DisableProcessorRequest(name=processor.name)
        operation = client.disable_processor(request)
    operation.result()  # Wait for operation to complete

def enable_processor(processor: docai.Processor):
    update_processor_state(processor, True)

def disable_processor(processor: docai.Processor):
    update_processor_state(processor, False)

أوقِف معالج تحليل النماذج، وتحقَّق من حالة المعالجات:

processor = get_processor(form_parser_display_name)
assert processor is not None

disable_processor(processor)
print_processors()

من المفترض أن تظهر لك المعلومات التالية:

+--------------+-----------------------+----------+
| display_name | type                  | state    |
+--------------+-----------------------+----------+
| document-ocr | OCR_PROCESSOR         | ENABLED  |
| form-parser  | FORM_PARSER_PROCESSOR | DISABLED |
+--------------+-----------------------+----------+
→ Processors: 2

إعادة تفعيل وحدة معالجة تحليل النماذج:

enable_processor(processor)
print_processors()

من المفترض أن تظهر لك المعلومات التالية:

+--------------+-----------------------+---------+
| display_name | type                  | state   |
+--------------+-----------------------+---------+
| document-ocr | OCR_PROCESSOR         | ENABLED |
| form-parser  | FORM_PARSER_PROCESSOR | ENABLED |
+--------------+-----------------------+---------+
→ Processors: 2

بعد ذلك، اطّلِع على كيفية إدارة إصدارات المعالج.

9. إدارة إصدارات المعالج

يمكن أن تتوفّر المعالجات بإصدارات متعددة. اطّلِع على كيفية استخدام الطريقتَين list_processor_versions وset_default_processor_version.

أضِف الدوالّ التالية:

def list_processor_versions(
    processor: docai.Processor,
) -> MutableSequence[docai.ProcessorVersion]:
    client = get_client()
    response = client.list_processor_versions(parent=processor.name)

    return list(response)


def get_sorted_processor_versions(
    processor: docai.Processor,
) -> MutableSequence[docai.ProcessorVersion]:
    def sort_key(processor_version: docai.ProcessorVersion):
        return processor_version.name

    versions = list_processor_versions(processor)

    return sorted(versions, key=sort_key)


def print_processor_versions(processor: docai.Processor):
    versions = get_sorted_processor_versions(processor)
    default_version_name = processor.default_processor_version
    data = processor_versions_tabular_data(versions, default_version_name)
    headers = next(data)
    colalign = next(data)

    print(tabulate(data, headers, tablefmt="pretty", colalign=colalign))
    print(f"→ Processor versions: {len(versions)}")


def processor_versions_tabular_data(
    versions: Sequence[docai.ProcessorVersion],
    default_version_name: str,
) -> Iterator[Tuple[str, str, str]]:
    yield ("version", "display name", "default")
    yield ("left", "left", "left")
    if not versions:
        yield ("-", "-", "-")
        return
    for version in versions:
        mapping = docai.DocumentProcessorServiceClient.parse_processor_version_path(
            version.name
        )
        processor_version = mapping["processor_version"]
        is_default = "Y" if version.name == default_version_name else ""
        yield (processor_version, version.display_name, is_default)

أدرِج الإصدارات المتاحة لمعالج OCR:

processor = get_processor(document_ocr_display_name)
assert processor is not None
print_processor_versions(processor)

يمكنك الحصول على إصدارات المعالج:

+--------------------------------+--------------------------+---------+
| version                        | display name             | default |
+--------------------------------+--------------------------+---------+
| pretrained-ocr-v1.0-2020-09-23 | Google Stable            |         |
| pretrained-ocr-v1.1-2022-09-12 | Google Release Candidate |         |
| pretrained-ocr-v1.2-2022-11-10 | Google Release Candidate |         |
| pretrained-ocr-v2.0-2023-06-02 | Google Stable            | Y       |
| pretrained-ocr-v2.1-2024-08-07 | Google Release Candidate |         |
+--------------------------------+--------------------------+---------+
→ Processor versions: 5

الآن، أضِف دالة لتغيير إصدار المعالج التلقائي:

def set_default_processor_version(processor: docai.Processor, version_name: str):
    client = get_client()
    request = docai.SetDefaultProcessorVersionRequest(
        processor=processor.name,
        default_processor_version=version_name,
    )

    operation = client.set_default_processor_version(request)
    operation.result()  # Wait for operation to complete

التبديل إلى أحدث إصدار من المعالج:

processor = get_processor(document_ocr_display_name)
assert processor is not None
versions = get_sorted_processor_versions(processor)

new_version = versions[-1]  # Latest version
set_default_processor_version(processor, new_version.name)

# Update the processor info
processor = get_processor(document_ocr_display_name)
assert processor is not None
print_processor_versions(processor)

يمكنك الحصول على إعدادات الإصدار الجديد:

+--------------------------------+--------------------------+---------+
| version                        | display name             | default |
+--------------------------------+--------------------------+---------+
| pretrained-ocr-v1.0-2020-09-23 | Google Stable            |         |
| pretrained-ocr-v1.1-2022-09-12 | Google Release Candidate |         |
| pretrained-ocr-v1.2-2022-11-10 | Google Release Candidate |         |
| pretrained-ocr-v2.0-2023-06-02 | Google Stable            |         |
| pretrained-ocr-v2.1-2024-08-07 | Google Release Candidate | Y       |
+--------------------------------+--------------------------+---------+
→ Processor versions: 5

بعد ذلك، تأتي طريقة إدارة المعالج النهائية (الحذف).

10. حذف المعالجات

أخيرًا، اطّلِع على كيفية استخدام طريقة delete_processor.

أضِف الدالة التالية:

def delete_processor(processor: docai.Processor):
    client = get_client()
    operation = client.delete_processor(name=processor.name)
    operation.result()  # Wait for operation to complete

حذف معالجات الاختبار:

processors_to_delete = [dn for dn, _ in test_processor_display_names_and_types]
print("Deleting processors...")

for processor in list_processors():
    if processor.display_name not in processors_to_delete:
        continue
    print(f"  Deleting {processor.display_name}...")
    delete_processor(processor)

print("Done\n")
print_processors()

من المفترض أن تظهر لك المعلومات التالية:

Deleting processors...
  Deleting form-parser...
  Deleting document-ocr...
Done

+--------------+------+-------+
| display_name | type | state |
+--------------+------+-------+
| -            | -    | -     |
+--------------+------+-------+
→ Processors: 0

لقد اطّلعت على جميع طرق إدارة المعالج. لقد أوشكت على الانتهاء...

11. تهانينا!

لقد تعرّفت على كيفية إدارة معالجات Document AI باستخدام لغة Python.

تَنظيم

لتنظيف بيئة التطوير، اتّبِع الخطوات التالية من Cloud Shell:

إذا كنت لا تزال في جلسة IPython، ارجع إلى shell: exit
توقّف عن استخدام بيئة Python الافتراضية: deactivate
حذف مجلد البيئة الافتراضية: cd ~ ; rm -rf ./venv-docai

لحذف مشروعك على Google Cloud، اتّبِع الخطوات التالية من Cloud Shell:

استرداد رقم تعريف مشروعك الحالي: PROJECT_ID=$(gcloud config get-value core/project)
تأكَّد من أنّ هذا هو المشروع الذي تريد حذفه: echo $PROJECT_ID
حذف المشروع: gcloud projects delete $PROJECT_ID

مزيد من المعلومات

جرِّب Document AI في المتصفّح: https://cloud.google.com/document-ai/docs/drag-and-drop
تفاصيل معالج Document AI: https://cloud.google.com/document-ai/docs/processors-list
Python على Google Cloud: https://cloud.google.com/python
مكتبات عملاء Cloud لبرنامج Python: https://github.com/googleapis/google-cloud-python

الترخيص

يخضع هذا العمل للترخيص العام Creative Commons Attribution 2.0.

الإبلاغ عن خطأ