moderation_api 1.0.0__py3-none-any.whl

moderation_api/types/content_submit_params.py

@@ -0,0 +1,352 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Iterable
+from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = [
+    "ContentSubmitParams",
+    "Content",
+    "ContentText",
+    "ContentImage",
+    "ContentVideo",
+    "ContentAudio",
+    "ContentObject",
+    "ContentObjectData",
+    "ContentObjectDataText",
+    "ContentObjectDataImage",
+    "ContentObjectDataVideo",
+    "ContentObjectDataAudio",
+    "Policy",
+    "PolicyToxicity",
+    "PolicyPersonalInformation",
+    "PolicyToxicitySevere",
+    "PolicyHate",
+    "PolicyIllicit",
+    "PolicyIllicitDrugs",
+    "PolicyIllicitAlcohol",
+    "PolicyIllicitFirearms",
+    "PolicyIllicitTobacco",
+    "PolicyIllicitGambling",
+    "PolicySexual",
+    "PolicyFlirtation",
+    "PolicyProfanity",
+    "PolicyViolence",
+    "PolicySelfHarm",
+    "PolicySpam",
+    "PolicySelfPromotion",
+    "PolicyPolitical",
+    "PolicyReligion",
+    "PolicyCodeAbuse",
+    "PolicyPiiMasking",
+    "PolicyPiiMaskingEntities",
+    "PolicyURLMasking",
+    "PolicyURLMaskingEntities",
+    "PolicyGuideline",
+]
+
+
+class ContentSubmitParams(TypedDict, total=False):
+    content: Required[Content]
+    """The content sent for moderation"""
+
+    author_id: Annotated[str, PropertyInfo(alias="authorId")]
+    """The author of the content."""
+
+    channel: str
+    """Provide a channel ID or key.
+
+    Will use the project's default channel if not provided.
+    """
+
+    content_id: Annotated[str, PropertyInfo(alias="contentId")]
+    """The unique ID of the content in your database."""
+
+    conversation_id: Annotated[str, PropertyInfo(alias="conversationId")]
+    """For example the ID of a chat room or a post"""
+
+    do_not_store: Annotated[bool, PropertyInfo(alias="doNotStore")]
+    """Do not store the content. The content won't enter the review queue"""
+
+    metadata: Dict[str, object]
+    """Any metadata you want to store with the content"""
+
+    meta_type: Annotated[
+        Literal["profile", "message", "post", "comment", "event", "product", "review", "other"],
+        PropertyInfo(alias="metaType"),
+    ]
+    """The meta type of content being moderated"""
+
+    policies: Iterable[Policy]
+    """(Enterprise) override the channel policies for this moderation request only."""
+
+
+class ContentText(TypedDict, total=False):
+    text: Required[str]
+    """The content text"""
+
+    type: Required[Literal["text"]]
+
+
+class ContentImage(TypedDict, total=False):
+    type: Required[Literal["image"]]
+
+    url: Required[str]
+    """A public URL of the image content"""
+
+
+class ContentVideo(TypedDict, total=False):
+    type: Required[Literal["video"]]
+
+    url: Required[str]
+    """A public URL of the video content"""
+
+
+class ContentAudio(TypedDict, total=False):
+    type: Required[Literal["audio"]]
+
+    url: Required[str]
+    """The URL of the audio content"""
+
+
+class ContentObjectDataText(TypedDict, total=False):
+    text: Required[str]
+    """The content text"""
+
+    type: Required[Literal["text"]]
+
+
+class ContentObjectDataImage(TypedDict, total=False):
+    type: Required[Literal["image"]]
+
+    url: Required[str]
+    """A public URL of the image content"""
+
+
+class ContentObjectDataVideo(TypedDict, total=False):
+    type: Required[Literal["video"]]
+
+    url: Required[str]
+    """A public URL of the video content"""
+
+
+class ContentObjectDataAudio(TypedDict, total=False):
+    type: Required[Literal["audio"]]
+
+    url: Required[str]
+    """The URL of the audio content"""
+
+
+ContentObjectData: TypeAlias = Union[
+    ContentObjectDataText, ContentObjectDataImage, ContentObjectDataVideo, ContentObjectDataAudio
+]
+
+
+class ContentObject(TypedDict, total=False):
+    data: Required[Dict[str, ContentObjectData]]
+    """Values in the object. Can be mixed content types."""
+
+    type: Required[Literal["object"]]
+
+
+Content: TypeAlias = Union[ContentText, ContentImage, ContentVideo, ContentAudio, ContentObject]
+
+
+class PolicyToxicity(TypedDict, total=False):
+    id: Required[Literal["toxicity"]]
+
+    flag: Required[bool]
+
+
+class PolicyPersonalInformation(TypedDict, total=False):
+    id: Required[Literal["personal_information"]]
+
+    flag: Required[bool]
+
+
+class PolicyToxicitySevere(TypedDict, total=False):
+    id: Required[Literal["toxicity_severe"]]
+
+    flag: Required[bool]
+
+
+class PolicyHate(TypedDict, total=False):
+    id: Required[Literal["hate"]]
+
+    flag: Required[bool]
+
+
+class PolicyIllicit(TypedDict, total=False):
+    id: Required[Literal["illicit"]]
+
+    flag: Required[bool]
+
+
+class PolicyIllicitDrugs(TypedDict, total=False):
+    id: Required[Literal["illicit_drugs"]]
+
+    flag: Required[bool]
+
+
+class PolicyIllicitAlcohol(TypedDict, total=False):
+    id: Required[Literal["illicit_alcohol"]]
+
+    flag: Required[bool]
+
+
+class PolicyIllicitFirearms(TypedDict, total=False):
+    id: Required[Literal["illicit_firearms"]]
+
+    flag: Required[bool]
+
+
+class PolicyIllicitTobacco(TypedDict, total=False):
+    id: Required[Literal["illicit_tobacco"]]
+
+    flag: Required[bool]
+
+
+class PolicyIllicitGambling(TypedDict, total=False):
+    id: Required[Literal["illicit_gambling"]]
+
+    flag: Required[bool]
+
+
+class PolicySexual(TypedDict, total=False):
+    id: Required[Literal["sexual"]]
+
+    flag: Required[bool]
+
+
+class PolicyFlirtation(TypedDict, total=False):
+    id: Required[Literal["flirtation"]]
+
+    flag: Required[bool]
+
+
+class PolicyProfanity(TypedDict, total=False):
+    id: Required[Literal["profanity"]]
+
+    flag: Required[bool]
+
+
+class PolicyViolence(TypedDict, total=False):
+    id: Required[Literal["violence"]]
+
+    flag: Required[bool]
+
+
+class PolicySelfHarm(TypedDict, total=False):
+    id: Required[Literal["self_harm"]]
+
+    flag: Required[bool]
+
+
+class PolicySpam(TypedDict, total=False):
+    id: Required[Literal["spam"]]
+
+    flag: Required[bool]
+
+
+class PolicySelfPromotion(TypedDict, total=False):
+    id: Required[Literal["self_promotion"]]
+
+    flag: Required[bool]
+
+
+class PolicyPolitical(TypedDict, total=False):
+    id: Required[Literal["political"]]
+
+    flag: Required[bool]
+
+
+class PolicyReligion(TypedDict, total=False):
+    id: Required[Literal["religion"]]
+
+    flag: Required[bool]
+
+
+class PolicyCodeAbuse(TypedDict, total=False):
+    id: Required[Literal["code_abuse"]]
+
+    flag: Required[bool]
+
+
+class PolicyPiiMaskingEntities(TypedDict, total=False):
+    id: Required[
+        Literal["email", "phone", "url", "address", "name", "username", "ip_address", "credit_card", "sensitive_other"]
+    ]
+
+    enable: Required[bool]
+
+    flag: Required[bool]
+
+    should_mask: Required[Annotated[bool, PropertyInfo(alias="shouldMask")]]
+
+    mask: str
+
+
+class PolicyPiiMasking(TypedDict, total=False):
+    id: Required[Literal["pii"]]
+
+    entities: Required[Dict[str, PolicyPiiMaskingEntities]]
+
+
+class PolicyURLMaskingEntities(TypedDict, total=False):
+    id: Required[
+        Literal["email", "phone", "url", "address", "name", "username", "ip_address", "credit_card", "sensitive_other"]
+    ]
+
+    enable: Required[bool]
+
+    flag: Required[bool]
+
+    should_mask: Required[Annotated[bool, PropertyInfo(alias="shouldMask")]]
+
+    mask: str
+
+
+class PolicyURLMasking(TypedDict, total=False):
+    id: Required[Literal["url"]]
+
+    entities: Required[Dict[str, PolicyURLMaskingEntities]]
+
+
+class PolicyGuideline(TypedDict, total=False):
+    id: Required[Literal["guideline"]]
+
+    flag: Required[bool]
+
+    guideline_key: Required[Annotated[str, PropertyInfo(alias="guidelineKey")]]
+
+    instructions: Required[str]
+
+
+Policy: TypeAlias = Union[
+    PolicyToxicity,
+    PolicyPersonalInformation,
+    PolicyToxicitySevere,
+    PolicyHate,
+    PolicyIllicit,
+    PolicyIllicitDrugs,
+    PolicyIllicitAlcohol,
+    PolicyIllicitFirearms,
+    PolicyIllicitTobacco,
+    PolicyIllicitGambling,
+    PolicySexual,
+    PolicyFlirtation,
+    PolicyProfanity,
+    PolicyViolence,
+    PolicySelfHarm,
+    PolicySpam,
+    PolicySelfPromotion,
+    PolicyPolitical,
+    PolicyReligion,
+    PolicyCodeAbuse,
+    PolicyPiiMasking,
+    PolicyURLMasking,
+    PolicyGuideline,
+]

moderation_api/types/content_submit_response.py

@@ -0,0 +1,269 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from .._models import BaseModel
+
+__all__ = [
+    "ContentSubmitResponse",
+    "Author",
+    "AuthorBlock",
+    "AuthorTrustLevel",
+    "Content",
+    "ContentModifiedModifiedNestedObjectContentContentModifiedModifiedNestedObjectContentItem",
+    "ContentModifiedModifiedNestedObjectContentContentModifiedModifiedNestedObjectContentItemText",
+    "ContentModifiedModifiedNestedObjectContentContentModifiedModifiedNestedObjectContentItemImage",
+    "ContentModifiedModifiedNestedObjectContentContentModifiedModifiedNestedObjectContentItemVideo",
+    "ContentModifiedModifiedNestedObjectContentContentModifiedModifiedNestedObjectContentItemAudio",
+    "Evaluation",
+    "Insight",
+    "InsightSentimentInsight",
+    "InsightLanguageInsight",
+    "Meta",
+    "Policy",
+    "PolicyClassifierOutput",
+    "PolicyClassifierOutputLabel",
+    "PolicyEntityMatcherOutput",
+    "PolicyEntityMatcherOutputMatch",
+    "Recommendation",
+    "Error",
+]
+
+
+class AuthorBlock(BaseModel):
+    reason: Optional[str] = None
+    """The moderators reason why the author was blocked or suspended."""
+
+    until: Optional[float] = None
+    """The timestamp until which they are blocked if the author is suspended."""
+
+
+class AuthorTrustLevel(BaseModel):
+    level: float
+    """Author trust level (-1, 0, 1, 2, 3, or 4)"""
+
+    manual: bool
+    """True if the trust level was set manually by a moderator"""
+
+
+class Author(BaseModel):
+    id: str
+    """Author ID in Moderation API"""
+
+    block: Optional[AuthorBlock] = None
+    """Block or suspension details, if applicable. Null if the author is enabled."""
+
+    status: Literal["enabled", "suspended", "blocked"]
+    """Current author status"""
+
+    trust_level: AuthorTrustLevel
+
+    external_id: Optional[str] = None
+    """The author's ID from your system"""
+
+
+class ContentModifiedModifiedNestedObjectContentContentModifiedModifiedNestedObjectContentItemText(BaseModel):
+    text: str
+    """The content text"""
+
+    type: Literal["text"]
+
+
+class ContentModifiedModifiedNestedObjectContentContentModifiedModifiedNestedObjectContentItemImage(BaseModel):
+    type: Literal["image"]
+
+    url: str
+    """A public URL of the image content"""
+
+
+class ContentModifiedModifiedNestedObjectContentContentModifiedModifiedNestedObjectContentItemVideo(BaseModel):
+    type: Literal["video"]
+
+    url: str
+    """A public URL of the video content"""
+
+
+class ContentModifiedModifiedNestedObjectContentContentModifiedModifiedNestedObjectContentItemAudio(BaseModel):
+    type: Literal["audio"]
+
+    url: str
+    """The URL of the audio content"""
+
+
+ContentModifiedModifiedNestedObjectContentContentModifiedModifiedNestedObjectContentItem: TypeAlias = Union[
+    ContentModifiedModifiedNestedObjectContentContentModifiedModifiedNestedObjectContentItemText,
+    ContentModifiedModifiedNestedObjectContentContentModifiedModifiedNestedObjectContentItemImage,
+    ContentModifiedModifiedNestedObjectContentContentModifiedModifiedNestedObjectContentItemVideo,
+    ContentModifiedModifiedNestedObjectContentContentModifiedModifiedNestedObjectContentItemAudio,
+]
+
+
+class Content(BaseModel):
+    id: str
+    """The unique identifier for the content.
+
+    Either the contentId provided by you or an autogenerated ID.
+    """
+
+    masked: bool
+    """Whether any values have been masked."""
+
+    modified: Union[
+        str,
+        Dict[str, object],
+        Dict[str, ContentModifiedModifiedNestedObjectContentContentModifiedModifiedNestedObjectContentItem],
+        None,
+    ] = None
+    """The modified content, if any."""
+
+
+class Evaluation(BaseModel):
+    flag_probability: float
+    """The probability that the content should be flagged."""
+
+    flagged: bool
+    """Whether the content was flagged by any policy."""
+
+    severity_score: float
+    """The severity score of the content.
+
+    A higher score indicates more severe content.
+    """
+
+    unicode_spoofed: Optional[bool] = None
+    """Whether the content was flagged for Unicode spoofing."""
+
+
+class InsightSentimentInsight(BaseModel):
+    id: Literal["sentiment"]
+
+    probability: float
+
+    type: Literal["insight"]
+
+    value: Optional[Literal["positive", "neutral", "negative"]] = None
+
+
+class InsightLanguageInsight(BaseModel):
+    id: Literal["language"]
+
+    probability: float
+
+    type: Literal["insight"]
+
+    value: Optional[str] = None
+
+
+Insight: TypeAlias = Union[InsightSentimentInsight, InsightLanguageInsight]
+
+
+class Meta(BaseModel):
+    channel_key: str
+    """The unique key of the channel where the content was handled.
+
+    Either the channel provided by you or automatically routed.
+    """
+
+    status: Literal["success", "partial_success"]
+
+    timestamp: float
+
+    usage: float
+
+    processing_time: Optional[str] = None
+
+
+class PolicyClassifierOutputLabel(BaseModel):
+    id: str
+
+    flagged: bool
+
+    probability: float
+
+
+class PolicyClassifierOutput(BaseModel):
+    id: str
+    """The unique identifier for the classifier output."""
+
+    flagged: bool
+
+    probability: float
+
+    type: Literal["classifier"]
+
+    flagged_fields: Optional[List[str]] = None
+    """The keys of the flagged fields if submitting an object."""
+
+    labels: Optional[List[PolicyClassifierOutputLabel]] = None
+
+
+class PolicyEntityMatcherOutputMatch(BaseModel):
+    match: str
+
+    probability: float
+
+    span: List[int]
+
+
+class PolicyEntityMatcherOutput(BaseModel):
+    id: str
+
+    flagged: bool
+
+    matches: List[PolicyEntityMatcherOutputMatch]
+
+    probability: float
+
+    type: Literal["entity_matcher"]
+
+    flagged_fields: Optional[List[str]] = None
+
+
+Policy: TypeAlias = Union[PolicyClassifierOutput, PolicyEntityMatcherOutput]
+
+
+class Recommendation(BaseModel):
+    action: Literal["review", "allow", "reject"]
+    """The action to take based on the recommendation"""
+
+    reason_codes: List[Literal["severity_reject", "severity_review", "author_block", "dry_run"]]
+    """The reason code for the recommendation.
+
+    Can be used to display a reason to the user.
+    """
+
+
+class Error(BaseModel):
+    id: str
+
+    message: str
+
+
+class ContentSubmitResponse(BaseModel):
+    author: Optional[Author] = None
+    """The author of the content if your account has authors enabled.
+
+    Requires you to send authorId when submitting content.
+    """
+
+    content: Content
+    """Potentially modified content."""
+
+    evaluation: Evaluation
+    """The evaluation of the content after running the channel policies."""
+
+    insights: List[Insight]
+    """Results of all insights enabled in the channel."""
+
+    meta: Meta
+    """Metadata about the moderation request"""
+
+    policies: List[Policy]
+    """Results of all policies in the channel. Sorted by highest probability."""
+
+    recommendation: Recommendation
+    """The recommendation for the content based on the evaluation."""
+
+    errors: Optional[List[Error]] = None
+    """Policies that had errors"""

moderation_api/types/queue/__init__.py

@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .item_list_params import ItemListParams as ItemListParams
+from .item_list_response import ItemListResponse as ItemListResponse
+from .item_resolve_params import ItemResolveParams as ItemResolveParams
+from .item_resolve_response import ItemResolveResponse as ItemResolveResponse
+from .item_unresolve_params import ItemUnresolveParams as ItemUnresolveParams
+from .item_unresolve_response import ItemUnresolveResponse as ItemUnresolveResponse

moderation_api/types/queue/item_list_params.py

@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Annotated, TypedDict
+
+from ..._utils import PropertyInfo
+
+__all__ = ["ItemListParams"]
+
+
+class ItemListParams(TypedDict, total=False):
+    after_date: Annotated[str, PropertyInfo(alias="afterDate")]
+
+    author_id: Annotated[str, PropertyInfo(alias="authorId")]
+
+    before_date: Annotated[str, PropertyInfo(alias="beforeDate")]
+
+    conversation_ids: Annotated[str, PropertyInfo(alias="conversationIds")]
+
+    filtered_action_ids: Annotated[str, PropertyInfo(alias="filteredActionIds")]
+
+    include_resolved: Annotated[str, PropertyInfo(alias="includeResolved")]
+
+    labels: str
+
+    page_number: Annotated[float, PropertyInfo(alias="pageNumber")]
+    """Page number to fetch"""
+
+    page_size: Annotated[float, PropertyInfo(alias="pageSize")]
+    """Number of items per page"""
+
+    sort_direction: Annotated[Literal["asc", "desc"], PropertyInfo(alias="sortDirection")]
+    """Sort direction"""
+
+    sort_field: Annotated[Literal["createdAt", "severity", "reviewedAt"], PropertyInfo(alias="sortField")]