用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/personamanagmentlayer/pcl --skill media-expert命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
Expert in Persona Control Language (PCL) - language design, compiler architecture, runtime systems, and ecosystem development
Expert system for designing, creating, and validating PCL skills with comprehensive domain knowledge extraction
Expert-level Docker containerization, image optimization, and container orchestration. Use this skill for building efficient Docker images, managing containers, and implementing Docker best practices.
基于 SOC 职业分类
正在显示 SKILL.md
| name | media-expert |
| version | 1.0.0 |
| description | Expert-level media production, content management, streaming, broadcasting, and media technology systems |
| category | domains |
| tags | ["media","video","streaming","broadcast","cms","production"] |
| allowed-tools | ["Read","Write","Edit"] |
Expert guidance for media production, content management systems, video streaming, broadcasting systems, and modern media technology solutions.
from dataclasses import dataclass
from datetime import datetime, timedelta
from typing import List, Optional, Dict
from decimal import Decimal
from enum import Enum
import hashlib
class MediaType(Enum):
VIDEO = "video"
AUDIO = "audio"
IMAGE = "image"
DOCUMENT = "document"
class AssetStatus(Enum):
DRAFT = "draft"
IN_REVIEW = "in_review"
APPROVED = "approved"
PUBLISHED = "published"
ARCHIVED = "archived"
@dataclass
class MediaAsset:
"""Media asset information"""
asset_id: str
title: str
description: str
media_type: MediaType
file_path: str
file_size_bytes: int
duration_seconds: Optional[float]
resolution: Optional[str] # e.g., "1920x1080"
codec: Optional[str]
bitrate_kbps: Optional[int]
frame_rate: Optional[float]
created_at: datetime
created_by:
status: AssetStatus
tags: []
metadata: [, ]
checksum:
:
package_id:
title:
assets: []
created_at: datetime
scheduled_publish: [datetime]
expiration_date: [datetime]
distribution_channels: []
:
():
.assets = {}
.packages = {}
.workflows = []
() -> MediaAsset:
checksum = ._calculate_checksum(file_path)
tech_metadata = ._extract_metadata(file_path)
asset = MediaAsset(
asset_id=._generate_asset_id(),
title=metadata[],
description=metadata.get(, ),
media_type=MediaType(metadata[]),
file_path=file_path,
file_size_bytes=tech_metadata[],
duration_seconds=tech_metadata.get(),
resolution=tech_metadata.get(),
codec=tech_metadata.get(),
bitrate_kbps=tech_metadata.get(),
frame_rate=tech_metadata.get(),
created_at=datetime.now(),
created_by=metadata[],
status=AssetStatus.DRAFT,
tags=metadata.get(, []),
metadata=metadata.get(, {}),
checksum=checksum
)
.assets[asset.asset_id] = asset
._trigger_workflows(asset)
asset
() -> :
{
: ,
: ,
: ,
: ,
: ,
:
}
() -> :
hashlib.sha256(file_path.encode()).hexdigest()
() -> :
asset = .assets.get(asset_id)
asset:
{: }
transcode_jobs = []
profile output_profiles:
job = {
: ._generate_job_id(),
: asset_id,
: profile[],
: profile[],
: profile[],
: profile[],
: ,
: ,
: datetime.now() + timedelta(hours=)
}
transcode_jobs.append(job)
{
: asset_id,
: transcode_jobs,
: (transcode_jobs)
}
() -> [MediaAsset]:
results = []
asset .assets.values():
=
query:
keywords = query[].lower()
keywords asset.title.lower() keywords asset.description.lower():
=
query asset.media_type.value != query[]:
=
query asset.status.value != query[]:
=
query:
required_tags = (query[])
asset_tags = (asset.tags)
required_tags.issubset(asset_tags):
=
query asset.created_at < query[]:
=
:
results.append(asset)
results
() -> ContentPackage:
package = ContentPackage(
package_id=._generate_package_id(),
title=package_data[],
assets=package_data[],
created_at=datetime.now(),
scheduled_publish=package_data.get(),
expiration_date=package_data.get(),
distribution_channels=package_data[]
)
.packages[package.package_id] = package
package
() -> :
asset = .assets.get(asset_id)
asset:
{: }
analysis = {
: asset_id,
: [, , ],
: [, , ],
: ,
: ,
: ,
: [, ],
: [, , ],
:
}
analysis
():
() -> :
uuid
() -> :
uuid
() -> :
uuid
class VideoStreamingPlatform:
"""Video streaming and delivery system"""
def __init__(self):
self.streams = {}
self.viewers = {}
self.cdn_nodes = {}
def start_live_stream(self, stream_data: dict) -> dict:
"""Start live video stream"""
stream_id = self._generate_stream_id()
stream = {
'stream_id': stream_id,
'title': stream_data['title'],
'description': stream_data.get('description', ''),
'streamer_id': stream_data['streamer_id'],
'status': 'live',
'started_at': datetime.now(),
'viewer_count': 0,
'peak_viewers': 0,
'ingest_url': f'rtmp://ingest.example.com/live/{stream_id}',
'playback_urls': {
'hls': f'https://cdn.example.com/live/{stream_id}/playlist.m3u8',
'dash': f'https://cdn.example.com/live/{stream_id}/manifest.mpd'
},
'quality_profiles': ['1080p', '720p', '480p', ]
}
.streams[stream_id] = stream
stream
() -> :
hls_variants = [
{
: ,
: ,
: ,
:
},
{
: ,
: ,
: ,
:
},
{
: ,
: ,
: ,
:
},
{
: ,
: ,
: ,
:
}
]
{
: asset_id,
: ,
: ,
: hls_variants
}
() -> :
metrics = {
: stream_id,
: viewer_id,
: ,
: ,
: ,
: ,
: ,
: ,
: ,
:
}
qoe_score = ._calculate_qoe(metrics)
metrics[] = qoe_score
metrics
() -> :
score =
score -= metrics[] *
metrics[] > :
score -=
score -= metrics[] *
(, score)
() -> :
drm = {
: asset_id,
: {
: {
: ,
: [, ]
},
: {
: ,
:
},
: {
:
}
},
: ,
:
}
drm
() -> :
nearest_node = ._find_nearest_cdn_node(viewer_location)
{
: asset_id,
: nearest_node[],
: nearest_node[],
: nearest_node[],
: nearest_node[],
:
}
() -> :
{
: ,
: ,
: ,
:
}
() -> :
uuid
class BroadcastAutomationSystem:
"""Broadcast scheduling and automation"""
def __init__(self):
self.schedule = []
self.playlists = {}
def create_broadcast_schedule(self, channel: str, date: datetime, programming: List[dict]) -> dict:
"""Create daily broadcast schedule"""
schedule_items = []
current_time = date.replace(hour=0, minute=0, second=0)
for program in programming:
item = {
'channel': channel,
'start_time': current_time,
'end_time': current_time + timedelta(seconds=program['duration']),
'program_title': program['title'],
'asset_id': program['asset_id'],
'type': program['type'], # 'program', 'commercial', 'filler'
'metadata': program.get('metadata', {})
}
schedule_items.append(item)
current_time = item['end_time']
self.schedule.extend(schedule_items)
return {
'channel': channel,
'date': date.date().isoformat(),
'total_items': len(schedule_items),
: (schedule_items[-][] - schedule_items[][]).seconds,
: schedule_items[:]
}
() -> :
playlist = {
: ._generate_playlist_id(),
: ,
: []
}
playlist
() -> :
status = {
: channel,
: ,
: ,
: ,
: ,
: ,
: {
: ,
: ,
:
},
: []
}
status
() -> :
uuid
❌ No backup systems ❌ Poor metadata management ❌ Single bitrate streaming ❌ No CDN implementation ❌ Ignoring QoE metrics ❌ Manual scheduling processes ❌ No DRM for premium content ❌ Poor asset organization ❌ No disaster recovery plan