Tüm Ürünler
Search
Belge Merkezi

Object Storage Service:Tutorial: Semantic search for IPCs

Son Güncelleme:Oct 02, 2026

OSS veri dizine alma özelliğini kullanarak Internet Protocol kamera (IPC) cihazlarından gelen videolar için akıllı bir anlamsal arama sistemi oluşturun. Bu sistem, toplanan videolarda anlamsal aramalar yapmanıza olanak tanır ve akıllı güvenlik gibi senaryolar için idealdir.

Not

Bu çözümde yer alan AI içerik farkındalığı özelliklerinin potansiyel maliyetlerini tahmin etmek için IPC Senaryosu - İçerik Farkındalığı Fiyat Hesaplayıcı aracını kullanın. (Alibaba Cloud hesabınızda oturum açmadıysanız önce oturum açın ve ardından bağlantıya tekrar tıklayın.)

Çözüm genel bakışı

image

Akıllı anlamsal arama sisteminin oluşturulması iki adımdan oluşur:

  1. Bir paket oluşturun ve videoları yükleyin: IPC cihazlarınızdan gelen ham video dosyalarını depolamak için bir paket oluşturun. Ardından işlemek istediğiniz videoları yükleyin. Bu videolar, aramalarınız için kaynak verileri sağlar.

  2. AISearch özelliğini etkinleştirin: Paket için AISearch özelliğini etkinleştirin. Bu sayede doğal dil açıklamalarını kullanan akıllı aramalar yapabilirsiniz.

Çözüm avantajları

  • Anlamsal arama: Doğal dil açıklamaları ve birden çok koşul kullanarak hassas aramalar yapmanıza olanak tanır. Bu özellik, karmaşık senaryolarda belirli video karelerini hızlıca bulmanıza yardımcı olur.

  • Çok modlu arama: Videolar, görüntüler ve metinler gibi farklı veri türleri için birleşik yönetim ve arama yetenekleri sunar. Bu sayede teknik karmaşıklık ile bakım ve işletim maliyetleri azaltılır.

  • Yatay ölçeklendirme: OSS sınırsız kapasite ve ölçeklenebilirlik sunar. Bu sayede büyük veri büyümesi kolaylıkla yönetilebilir.

1. Bir paket oluşturun ve videoları yükleyin

  1. OSS konsolu üzerinde oturum açın.

  2. Buckets sayfasında, Create Bucket seçeneğine tıklayın.

  3. Create Bucket sayfasında bir paket adı girin. İşle ilgili bir ad kullanın; örneğin, ipc-videos-oss-metaquery-demo. Diğer parametreler için varsayılan ayarları koruyabilirsiniz.

  4. Create öğesine tıklayın. Başarı sayfasında, Go to Bucket seçeneğine tıklayın.

  5. Objects sayfasında, Upload Object > Select Files seçeneklerine tıklayın. Yüklemek istediğiniz video dosyalarını seçin; örneğin, videoA.mp4, videoB.mp4 ve videoC.mp4. Diğer parametreler için varsayılan ayarları koruyun ve Upload Object seçeneğine tıklayın.

  6. (İsteğe bağlı) Yüklenen video dosyalarına etiket ekleyin. Hedef dosyanın Actions sütununda, more > Tag yolunu izleyin. Görüntülenen iletişim kutusunda anahtar-değer çiftleri ekleyin. Örneğin, dizini oluştururken filtreleme koşulu olarak kullanmak üzere anahtarı need-seek ve değeri true olarak ayarlayabilirsiniz. Ayrıca, sorgular için filtreleme koşulu olarak kullanmak üzere anahtarı camera ve değeri camera-a olarak ayarlayabilirsiniz. OK seçeneğine tıklayın. Etiketler, dizine alma ve arama sırasında daha hassas filtreleme yapılmasına olanak tanır.

2. AISearch özelliğini etkinleştirin

Doğal dil açıklamaları ve birden çok koşul kullanan videoların hassas bir şekilde aranmasını sağlamak için paketin AISearch özelliğini etkinleştirin.

  1. Sol gezinme bölmesinde, Object Management > Data Indexing seçeneğini belirleyin.

  2. Data Indexing sayfasında, veri dizine alma özelliğini ilk kez kullanıyorsanız ekrandaki talimatları izleyerek AliyunMetaQueryDefaultRole rolüne paketinizdeki verileri yönetmesi için OSS izinlerini verin. İzinleri verdikten sonra Enable Data Index seçeneğine tıklayın ve AISearch seçeneğini belirleyin.

  3. (İsteğe bağlı) AI İçerik Farkındalığı: Gerektiğinde Image Content Awareness veya Video Content Awareness seçeneğini belirleyin.

  4. (İsteğe bağlı) Dosya filtreleme kuralları: Yalnızca belirli kurallarla eşleşen dosyalarda AI analizi gerçekleştirmek için bu özelliği yapılandırın. En fazla beş dosya filtreleme kuralı ayarlayabilirsiniz. Ön ek, dosya boyutu, etiket ve LastModifiedTime'a göre filtreleme desteklenir. Örneğin, anahtarı need-seek ve değeri true olan bir etiket filtreleme kuralı ekleyin. Yapılandırmadan sonra sistem yalnızca bu etikete sahip dosyaları dizine alır.

    Not

    Dosya filtrelemeyi etkinleştirirseniz veri dizini (AISearch) ve içerik farkındalığı özellikleri için yalnızca filtrelenen dosya sayısına göre ücretlendirilirsiniz.

  5. Enable seçeneğine tıklayın.

Not

Meta veri dizininin oluşturulması biraz zaman alır. Süre, paketteki nesne sayısına bağlıdır. Çok uzun sürerse etkinleştirme durumunu kontrol etmek için sayfayı yenileyebilirsiniz.

image

image

Sonuçları doğrulayın

a yard with a parked car gibi açıklayıcı bir ifade girin; sistem, açıklamayla eşleşen ilgili videoları döndürür.

  1. Buckets sayfasında paketinizin adına tıklayın.

  2. Objects sayfasında videoların yüklendiğini doğrulayın.

  3. Sol gezinme bölmesinde, Object Management > Data Indexing seçeneğini belirleyin.

  4. Data Indexing sayfasında, arama kutusuna a yard with a parked car ifadesini girin. Multimedia Type bölümünde, video onay kutusunu seçin.

  5. (İsteğe bağlı) Object Tagging bölümünde, anahtarı camera ve değeri camera-a olarak ayarlayın. Sistem yalnızca camera=camera-a etiketine sahip videoları döndürür ve diğer tüm videoları filtreler.

  6. Query Now seçeneğine tıklayın.

  7. Sorgu sonuçlarından dosya yolunu kopyalayın. Objects sayfasına geri dönün, dosya yolunu arama kutusuna yapıştırın ve aramayı gerçekleştirin. Artık açıklamayla eşleşen videoyu görebilirsiniz.

2025-05-23_16-41-02 (1)

Canlı ortama geçiş

Bu özelliği üretim ortamına entegre ederken aşağıdaki hususları göz önünde bulundurun:

Üretim verilerinin alınması

Tipik bir iş senaryosunda, IPC'ler gibi izleme cihazları sürekli olarak büyük miktarda video verisi üretir. Kaydedilen video segmentlerini gerçek zamanlı olarak belirtilen pakete yüklemek için OSS SDK'sını entegre etmenizi öneririz. Bu yaklaşım, veri yüklemelerinin kararlılığını ve zamanlamasını garanti ederek sistemin genel kullanılabilirliğini ve gerçek zamanlı işleme yeteneklerini iyileştirir.

Aşağıdaki örnekte, bir video dosyasını yüklemek için OSS Python SDK'nın Upload Manager özelliğinin nasıl kullanılacağı gösterilmektedir:

Kod örneği

import argparse
import alibabacloud_oss_v2 as oss
from alibabacloud_oss_v2.models import ListObjectsRequest, PutObjectTaggingRequest, Tagging, TagSet, Tag, PutObjectRequest
import os

def upload_video(client, bucket, video_config):
    """Upload a video."""
    try:
        # Check if the file exists.
        if not os.path.exists(video_config['path']):
            print(f'File does not exist: {video_config["path"]}')
            return False

        # Create an uploader object.
        uploader = client.uploader()

        # Execute the upload request - pass the filepath parameter correctly.
        result = uploader.upload_file(
            filepath=video_config['path'],  # Add the filepath parameter.
            request=PutObjectRequest(
                bucket=bucket,
                key=video_config['key']
            )
        )

        print(f'Successfully uploaded {video_config["key"]}:')
        print(f'status code: {result.status_code},'
              f' request id: {result.request_id}')
        return True
    except Exception as e:
        print(f'Failed to upload {video_config["key"]}: {str(e)}')
        return False

def main():
    # OSS configuration.
    args = argparse.Namespace(
        region='cn-beijing',
        bucket='ipc-videos-oss-metaquery-demo',
        endpoint='https://oss-cn-beijing.aliyuncs.com'
    )

    # Configure the OSS client.
    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()
    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    cfg.endpoint = args.endpoint
    client = oss.Client(cfg)

    # Video file configurations, including different tags.
    videos = [
        {
            'path': '<Your-Path>/videoa.mp4',
            'key': 'videoa.mp4'
        },
        {
            'path': '<Your-Path>/videob.mp4',
            'key': 'videob.mp4'
        },
        {
            'path': '<Your-Path>/videoc.mp4',
            'key': 'videoc.mp4'
        }
    ]

    # Upload all videos.
    for video in videos:
        print(f"\nStart uploading video: {video['key']}")
        upload_video(
            client=client,
            bucket=args.bucket,
            video_config=video
        )

if __name__ == "__main__":
    main()

Arama yeteneğinin entegrasyonu

Üretim ortamında, arama özelliğini arka uç hizmetinize entegre etmenizi öneririz. Konsolda manuel işlemler gerçekleştirmekten kaçınmak için otomatik çağrılar yapmak üzere OSS SDK'sını kullanabilirsiniz.

Aşağıdaki kod örneğinde, arama sonuçlarını almak için OSS MetaQuery belirtimine uygun bir XML isteğinin nasıl oluşturulacağı gösterilmektedir:

Kod örneği

# -*- coding: utf-8 -*-
import argparse
import alibabacloud_oss_v2 as oss
# Parse the XML response.
import xml.etree.ElementTree as ET
import json 
from datetime import datetime 

def get_search_conditions():
    """Get the user's multi-conditional input."""
    print("Enter a semantic description (example: a yard with a parked car)")
    query = input("> Semantic keywords: ").strip()
    while not query:
        print("Semantic keywords cannot be empty!")
        query = input("> Semantic keywords: ").strip()
    return query  

def build_metaquery_xml(query):
    """Build a MetaQuery XML that complies with the OSS specification."""
    xml_parts = [f'<Query>{query}</Query>']
    # Add the MediaTypes tag. Here, it is hard-coded as video.
    xml_parts.append('<MediaTypes><MediaType>video</MediaType></MediaTypes>')

    meta_query_xml = f'''<MetaQuery>
    {"".join(xml_parts)}
</MetaQuery>'''
    return meta_query_xml  # Encode into a UTF-8 byte stream.

def format_result(key, pre_url):
    """Format a single search result."""
    return f""" File path: {key}
 File URL: {pre_url}
-----------------------"""

def semantic_search():
    # Directly assign command-line arguments.
    args = argparse.Namespace(
        region = 'cn-beijing',  # Replace with your region.
        bucket = 'ipc-videos-oss-metaquery-demo',  # Replace with your bucket name.
        endpoint = 'https://oss-cn-beijing.aliyuncs.com',  # Replace with your endpoint. You can leave it empty or delete it if not needed.
    )

    # Initialize the OSS client.
    credentials = oss.credentials.EnvironmentVariableCredentialsProvider()
    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials
    cfg.region = args.region
    if args.endpoint:
        cfg.endpoint = args.endpoint
    client = oss.Client(cfg)

    # Get user input.
    query = get_search_conditions()  # Get only the query.
    # Build the request.
    try:
        # Construct the request body (XML data).
        data_str = build_metaquery_xml(query)

        # Define the operation input.
        req = oss.OperationInput(
            op_name='DoMetaQuery',  # Custom action name.
            method='POST',            # HTTP method.
            parameters={              # Query parameters.
                'metaQuery': '',
                'mode': 'semantic',
                'comp': 'query',
            },
            headers=None,             # Custom request header (optional).
            body=data_str.encode("utf-8"),  # Request body (encoded as a UTF-8 byte stream).
            bucket=args.bucket,       # Destination bucket name.
        )

        # Call the generic interface to execute the operation.
        resp = client.invoke_operation(req)

    except oss.exceptions.ServiceError as e:
        print(f" Server-side error: {e.message}")
        return
    
    root = ET.fromstring(resp.http_response.content.decode('utf-8'))
     # Find all File elements.
    files = root.findall('.//File')
    
    print(f"\n Found {len(files)} matching results:")
    

    for i, file in enumerate(files, 1):
        print(f"\nFile {i}:")

        # Extract and print various properties.
        uri_element = file.find('URI')
        uri = uri_element.text if uri_element is not None else 'N/A'
        print(f"  URI: {uri}")

        key_element = file.find('Filename')
        key = key_element.text if key_element is not None else 'N/A'
        print(f"  File name: {key}")

        size_element = file.find('Size')
        size = size_element.text if size_element is not None else 'N/A'
        print(f"  Size: {size}")

        modified_time_element = file.find('FileModifiedTime')
        modified_time = modified_time_element.text if modified_time_element is not None else 'N/A'
        print(f"  Last modified: {modified_time}")

        content_type_element = file.find('ContentType')
        content_type = content_type_element.text if content_type_element is not None else 'N/A'
        print(f"  ContentType: {content_type}")

        media_type_element = file.find('MediaType')
        media_type = media_type_element.text if media_type_element is not None else 'N/A'
        print(f"  MediaType: {media_type}")

        # You can add extraction and printing for more properties as needed, such as ImageHeight, ImageWidth, OSSStorageClass, etc.
        # image_height_element = file.find('ImageHeight')
        # image_height = image_height_element.text if image_height_element is not None else 'N/A'
        # print(f"  ImageHeight: {image_height}")

        # Generate a signed URL (if needed).
        if key != 'N/A': # Generate a URL only if the file name exists.
             try:
                pre_url = client.presign(
                    oss.GetObjectRequest(
                        bucket=args.bucket,  # Specify the bucket name.
                        key=key,        # Specify the object key.
                    )
                )
                print(f"  File URL (signed URL): {pre_url.url}")
             except Exception as e:
                 print(f"  Failed to generate signed URL: {e}")

        print("-" * 20) # Separator.
        
if __name__ == "__main__":
    semantic_search()

Programı çalıştırdıktan sonra, sorgulamak için a yard with a parked car gibi açıklayıcı bir ifade girebilirsiniz. Sistem, veri dizininden açıklamayla eşleşen arama sonuçlarını döndürür. URL'yi kullanarak video ayrıntılarını görüntüleyebilirsiniz.

Found 1 matching result:

File 1:
  URI: oss://ipc-videos-oss-metaquery-demo/videoA.mp4
  File name: videoA.mp4
  Size: 2311252
  Last modified: 2025-05-23T17:38:10+08:00
  ContentType: video/mp4
  MediaType: video
  File URL (signed URL): https://ipc-videos-oss-metaquery-demo.oss-cn-beijing.aliyuncs.com/%E8%A7%86%E9%A2%91A.mp4?x-oss-signature-version=OSS4-HMAC-SHA256&x-oss-date=20250523T094511Z&x-oss-expires=900&x-oss-credential=LTAI********************%2F20250523%2Fcn-beijing%2Foss%2Faliyun_v4_request&x-oss-signature=0bf38092c42a179ff0e8334c8bea3fd92f5a78599038e816e2ed3e02755542af
--------------------

Etiket filtrelemeyi ayarlama

Büyük miktarda video verisiyle çalışırken, yalnızca yola göre dosya yönetmek genellikle arama ve kategorilendirme açısından verimsizdir. OSS nesne etiketleme özelliğini kullanmanızı öneririz. Dosyalara anahtar-değer etiketleri ekleyerek iş ihtiyaçlarınıza göre verileri hızlıca filtreleyebilir ve kategorilere ayırabilirsiniz; örneğin, kamera kimliğine veya coğrafi bölgeye göre filtreleme yapabilirsiniz.

Sistemde aşağıdaki üç video dosyasını analiz etmek istediğinizi varsayalım: videoA.mp4, videoB.mp4 ve videoC.mp4.


videoA.mp4


videoB.mp4


videoC.mp4

example

example (1)

example


Arka bahçe videosu, camera-a tarafından çekildiği şeklinde işaretlendi


Satış videosu, camera-b tarafından çekildiği şeklinde işaretlendi


Arka bahçe videosu, içeriği A videosuna benzer, camera-c tarafından çekildiği şeklinde işaretlendi

Etiketler, dosyaları yüklerken ayarlanabilir veya farklı iş senaryolarının gereksinimlerini karşılamak için yüklemeden sonra dinamik olarak yönetilebilir.

Yükleme sırasında etiketleri ayarlama

Video dosyalarını yüklerken etiketleri ayarlayarak yükleme ve etiket yönetimi işlemlerini birleştirebilirsiniz. Bu yaklaşım, veri yönetiminin verimliliğini artırır.

Aşağıdaki örnekte, bir video dosyasını yüklemek ve aynı anda etiketleri ayarlamak için OSS Python SDK'nın Upload Manager özelliğinin nasıl kullanılacağı gösterilmektedir:

Kod örneği

import argparse
import alibabacloud_oss_v2 as oss
from alibabacloud_oss_v2.models import PutObjectRequest
import os

def upload_video_with_tags(client, bucket, video_config):
    """Upload a video with tags."""
    try:
        # Check if the file exists.
        if not os.path.exists(video_config['path']):
            print(f'File does not exist: {video_config["path"]}')
            return False

        # Create an uploader object.
        uploader = client.uploader()

        # Use the tagging string directly (encoding is not required if both key and value are simple strings).
        tagging_str = f"camera={video_config['camera_tag']}"

        # Execute the upload request - include tags directly.
        result = uploader.upload_file(
            filepath=video_config['path'],
            request=PutObjectRequest(
                bucket=bucket,
                key=video_config['key'],
                tagging=tagging_str
            )
        )

        print(f'Successfully uploaded {video_config["key"]}:')
        print(f'status code: {result.status_code},'
              f' request id: {result.request_id}')
        print(f'Tags added: {tagging_str}')
        return True
    except Exception as e:
        print(f'Failed to upload {video_config["key"]}: {str(e)}')
        return False

def main():
    # OSS configuration.
    args = argparse.Namespace(
        region='cn-beijing',
        bucket='ipc-videos-oss-metaquery-demo',
        endpoint='https://oss-cn-beijing.aliyuncs.com'
    )

    # Configure the OSS client.
    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()
    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    cfg.endpoint = args.endpoint
    client = oss.Client(cfg)

    # Video file configurations, including different tags.
    videos = [
        {
            'path': '<Your-Path>/videoa.mp4',
            'key': 'videoa.mp4',
            'camera_tag': 'camera-a'
        },
        {
            'path': '<Your-Path>/videob.mp4',
            'key': 'videob.mp4',
            'camera_tag': 'camera-b'
        },
        {
            'path': '<Your-Path>/videoc.mp4',
            'key': 'videoc.mp4',
            'camera_tag': 'camera-c'
        }
    ]

    # Upload all videos and add tags.
    for video in videos:
        print(f"\nStart uploading video: {video['key']}")
        upload_video_with_tags(
            client=client,
            bucket=args.bucket,
            video_config=video
        )

if __name__ == "__main__":
    main()
Yüklemeden sonra etiketleri yönetme

Bir dosya zaten yüklendiyse, etiketlerini istediğiniz zaman ekleyebilir veya değiştirebilirsiniz. Bu sayede veri etiketlerinin dinamik bakımı ve doğruluğu sağlanır.

Aşağıdaki örnekte, Python SDK'yı kullanarak etiket eklemek için ilgili arayüzün nasıl çağrılacağı gösterilmektedir:

Kod örneği

import argparse
import alibabacloud_oss_v2 as oss
from alibabacloud_oss_v2.models import GetObjectTaggingRequest, PutObjectTaggingRequest, Tagging, TagSet, Tag

def apply_tags_to_frame(client, bucket, frame_key, tags):
    """Add tags to a video."""
    try:
        # Build the tagging object.
        tagging = Tagging(
            version=1,
            tag_set=TagSet(tags=tags)
        )
        
        # Create a request to update tags.
        put_tag_request = PutObjectTaggingRequest(
            bucket=bucket,
            key=frame_key,
            tagging=tagging
        )
        
        # Update object tags.
        result = client.put_object_tagging(put_tag_request)
        
        # Convert tags to a string for printing.
        tags_str = '&'.join([f"{tag.key}={tag.value}" for tag in tags])
        print(f"Successfully added tags to {frame_key}: {tags_str}")
        return True
    except Exception as e:
        print(f"Failed to add tags: {str(e)}")
        return False

def frame_tags():
    # OSS configuration.
    args = argparse.Namespace(
        region='cn-beijing',   
        frame_bucket='ipc-videos-oss-metaquery-demo',     
        endpoint='https://oss-cn-beijing.aliyuncs.com'
    )
    
    # Configure the OSS client.
    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()
    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    cfg.endpoint = args.endpoint
    client = oss.Client(cfg)

    # Configure your video names.
    videos = [
        'videoa.mp4',    
        'videob.mp4',
        'videoc.mp4'
    ]

    # Process each video.
    for video_filename in videos:
        print(f"\nStart processing tags for video {video_filename}") # Print the originally extracted file name.

        # Remove the file name extension, for example, 'videoa.mp4' -> 'videoa'.
        # The sample code extracts the last character of the video file name as the camera identifier. This is for reference only. You can add tags based on your actual business requirements.
        video_name_base = video_filename.split('.')[0] if '.' in video_filename else video_filename
        tags = [
            Tag(key='camera', value=f'camera-{video_name_base[-1].lower()}' if video_name_base else 'camera-unknown'),
            # Tag(key='category', value='video_monitoring')       # Add actual business category information.
        ]

        # Add tags to the video.
        apply_tags_to_frame(client, args.frame_bucket, video_filename, tags)

        print(f"Finished processing tags for video {video_filename}\n") # Print the originally extracted file name.

if __name__ == "__main__":
    frame_tags()
Etiket filtrelemeyi arama ile birleştirme

Aşağıdaki örnekte, anlamsal anlayışı etiket filtreleme ile birleştiren bir sorgu isteğinin OSS Python SDK kullanılarak nasıl başlatılacağı gösterilmektedir:

Kod örneği

# -*- coding: utf-8 -*-
import argparse
import alibabacloud_oss_v2 as oss
# Parse the XML response.
import xml.etree.ElementTree as ET
import json
from datetime import datetime
# --- New import ---
from alibabacloud_oss_v2.models import GetObjectTaggingRequest
# --- End of new import ---

def get_inputs():
    """Get the user's semantic query (required) and filter conditions (optional)."""
    # 1. Get the required semantic query.
    print(" Enter a semantic description (example: a yard with a parked car)")
    query = input("> Semantic keywords: ").strip()
    while not query:
        print(" Semantic keywords cannot be empty!")
        query = input("> Semantic keywords: ").strip()

    conditions = [] # Initialize the list of filter conditions.
    target_tag = None # --- Used to store the target tag ---

    # 2. Get the optional tag filter.
    print("\n (Optional) Enter a tag filter condition (will be used for client-side filtering, example: camera=camera-a, press Enter to skip)") 
    tag_input = input("> Tag (format key=value): ").strip()
    if tag_input:
        if '=' in tag_input:
            # conditions.append({
            #     'field': 'Tags',
            #     'value': tag_input,
            #     'op': 'eq'
            # })
            target_tag = tag_input
            print(f" Info: The tag '{target_tag}' will be used for client-side filtering after results are retrieved.")
        else:
             print(" Incorrect tag format. Ignored. Please use the 'key=value' format.")

    # --- Return target_tag ---
    return query, conditions, target_tag

def build_metaquery_xml(query, conditions):
    """Build a MetaQuery XML that complies with the OSS specification (includes semantic query and optional filters)."""
    # Always include the semantic query part.
    xml_parts = [f'<Query>{query}</Query>']
    
    # Add media type restriction.
    xml_parts.append('<MediaTypes><MediaType>video</MediaType></MediaTypes>')
    
    # Add optional filter conditions - in semantic mode, only some fields are supported (such as Filename here).
    for cond in conditions:
        # In semantic mode, skip building SimpleQuery for the Tags field (although we no longer add Tags to conditions, this is kept just in case).
        if cond['field'] == 'Tags':
            continue

        json_query = json.dumps({
            "Field": cond['field'],
            "Value": cond['value'],
            "Operation": cond['op']
        }, ensure_ascii=False)
        xml_parts.append(f'<SimpleQuery>{json_query}</SimpleQuery>')

    # Combine into a complete MetaQuery XML.
    meta_query_xml = f'''<MetaQuery>
    {"".join(xml_parts)}
</MetaQuery>'''
    return meta_query_xml

def format_result(key, pre_url):
    """Format a single search result."""
    return f""" File URL: {pre_url}
 File path: {key}
-----------------------"""

def perform_search():
    # Directly assign command-line arguments.
    args = argparse.Namespace(
        region='cn-beijing',  # Replace with your region.
        bucket='ipc-videos-oss-metaquery-demo',  # Replace with your bucket name.
        endpoint='https://oss-cn-beijing.aliyuncs.com',  # Replace with your endpoint.
    )

    # Initialize the OSS client.
    credentials = oss.credentials.EnvironmentVariableCredentialsProvider()
    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials
    cfg.region = args.region
    if args.endpoint:
        cfg.endpoint = args.endpoint
    client = oss.Client(cfg)

    # Get user input (semantic query + optional conditions + target tag).
    query, conditions, target_tag = get_inputs()

    # Build the request.
    try:
        # Construct the request body (XML data).
        # --- Pass only conditions (without Tags) ---
        data_str = build_metaquery_xml(query, conditions)

        # Define the operation input.
        req = oss.OperationInput(
            op_name='DoMetaQuery',
            method='POST',
            parameters={
                'metaQuery': '',
                'mode': 'semantic', # <-- Re-add semantic mode.
                'comp': 'query',
            },
            headers=None,
            body=data_str.encode("utf-8"),
            bucket=args.bucket,
        )

        # Call the generic interface to execute the operation.
        print("\n Sending DoMetaQuery request...")
        resp = client.invoke_operation(req)
        print(f"\n Request successful, HTTP status code: {resp.http_response.status_code}")
    except oss.exceptions.ServiceError as e:
        print(f" Server-side error (ServiceError): {e.message}")
        print(f"   - HTTP Status Code: {e.status_code}")
        print(f"   - Error Code: {e.error_code}")
        print(f"   - Request ID: {e.request_id}")
        return
    except oss.exceptions.ClientError as e: # Add catch for client errors.
        print(f" Client or network error (ClientError): {e.message}")
        return
    except Exception as e: # Catch other possible exceptions.
        print(f" Unknown error: {e}")
        import traceback
        traceback.print_exc() # Print the full traceback.
        return

    # Parse and process the results...
    final_results_count = 0 # --- New: Counter to tally the final qualifying results ---
    try:
        root = ET.fromstring(resp.http_response.content.decode('utf-8'))
        # Find all File elements.
        files = root.findall('.//File')

        print(f"\n Retrieved {len(files)} initial matches from OSS. Starting client-side tag filtering...")

        if not files:
            # Check for NextContinuationToken, paging may be required.
            next_token_elem = root.find('.//NextContinuationToken')
            if next_token_elem is not None and next_token_elem.text:
                print(" Note: There may be more results. The current implementation does not handle paging.")
            print("\n No initial matches found.")
            return # Return early if no files are found.

        for i, file in enumerate(files, 1):
            # Get the file name.
            key_element = file.find('Filename')
            if key_element is None:
                print(f" Warning: The {i}-th initial result is missing the Filename field. Skipped.")
                continue
            key = key_element.text

            # --- Client-side tag filtering ---
            if target_tag:
                try:
                    tagging_req = GetObjectTaggingRequest(bucket=args.bucket, key=key)
                    tagging_resp = client.get_object_tagging(tagging_req)
                    # Check if the returned tag set contains the target tag.
                    tag_found = False
                    target_k, target_v = target_tag.split('=', 1)

                    if tagging_resp.tag_set and tagging_resp.tag_set.tags: # Use .tags
                        for tag in tagging_resp.tag_set.tags: # Use .tags

                            if tag.key == target_k and tag.value == target_v:
                                tag_found = True
                                break
                    if not tag_found:
                        continue # Tag does not match, skip this file.
                except oss.exceptions.ServiceError as tag_err:
                     if tag_err.status_code == 404 and tag_err.error_code == 'NoSuchTagSet':
                         continue
                     else:
                        print(f" Warning: Error getting tags for file '{key}': {tag_err.error_code} - {tag_err.message}. Skipped.")
                        continue
                except Exception as tag_e:
                    print(f" Warning: Unknown error occurred while getting or processing tags for file '{key}': {tag_e}. Skipped.")
                    # --- Add traceback for debugging ---
                    import traceback
                    traceback.print_exc()
                    # --- End of addition ---
                    continue
            # --- End of client-side tag filtering ---

            # --- If it passes the tag filter (or if no tag filter is set), process and print the result ---
            final_results_count += 1 # Increment the final result counter.
            print(f"\n[{final_results_count}] File '{key}' matches all conditions:") # Print the final result number.

            # Generate a signed URL.
            try:
                pre_url = client.presign(
                    oss.GetObjectRequest(
                        bucket=args.bucket,
                        key=key,
                    )
                )
                print(format_result(key, pre_url.url))
            except Exception as presign_e:
                print(f" Warning: Error generating signed URL for file '{key}': {presign_e}")
                print(format_result(key, "[Could not generate URL]"))
        # --- Print final statistics after the loop ---
        print(f"\n Client-side filtering complete. Found {final_results_count} final matching results.")

    except ET.ParseError as xml_e:
        print(f" Error: Failed to parse OSS response XML - {xml_e}")
    except Exception as parse_e:
        print(f" Error: An unexpected error occurred while processing results - {parse_e}")

if __name__ == "__main__":
    perform_search()

Programı çalıştırdıktan sonra, park edilmiş bir araba içeren avluyu içeren videoları filtreleyebilirsiniz:

  1. Açıklayıcı alana aşağıdaki arama anahtar sözcüğünü girin: a yard with a parked car

  2. Aşağıdaki etiket filtreleme koşulunu ayarlayın: camera = camera-a

Bu örnekte, hem A videosu hem de C videosu a yard with a parked car açıklamasıyla eşleşen bir sahne içermektedir. Ancak, yalnızca camera-a ile işaretlenen videoların sonuçlarını döndürecek şekilde bir etiket filtresi ayarladığınız için nihai arama sonucu yalnızca A videosunu içerir.

Sending DoMetaQuery request...

Request successful, HTTP status code: 200

Retrieved 2 initial matches from OSS. Starting client-side tag filtering...

[1] File 'videoA.mp4' matches all conditions:
 File URL: https://ipc-videos-oss-metaquery-demo.oss-cn-beijing.aliyuncs.com/%E8%A7%86%E9%A2%91A.mp4?x-oss-signature-version=OSS4-HMAC-SHA256&x-oss-date=20250526T054908Z&x-oss-expires=900&x-oss-credential=LTAI********************%2Fcn-beijing%2Foss%2Faliyun_v4_request&x-oss-signature=01bbf29790763d8e0f177d4cb0469cb00ae1c69d565219edb3866f75110b37ab
 File path: videoA.mp4
-----------------------

 Client-side filtering complete. Found 1 final matching result.