Skip to content

API Reference - Models

This page documents all the data models used by the USPTO ODP Python Client. These models represent the response structures from the USPTO API.

Patent Application Models

PatentFileWrapper

uspto_odp.models.patent_file_wrapper.PatentFileWrapper dataclass

Main class representing a patent file wrapper

Source code in src/uspto_odp/models/patent_file_wrapper.py 
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
@dataclass
class PatentFileWrapper:
    """Main class representing a patent file wrapper"""
    application_number: str
    events: List[Event]
    metadata: ApplicationMetadata
    inventors: List[Inventor]
    confirmation_number: Optional[str] = None
    customer_number: Optional[int] = None
    docket_number: Optional[str] = None
    @classmethod
    def from_dict(cls, data: dict) -> 'PatentFileWrapper':
        wrapper_data = data.get('patentFileWrapperDataBag', [{}])[0]

        return cls(
            application_number=wrapper_data.get('applicationNumberText', ''),
            events=[Event.from_dict(event) for event in wrapper_data.get('eventDataBag', [])],
            metadata=ApplicationMetadata.from_dict(wrapper_data.get('applicationMetaData', {})),
            inventors=[Inventor.from_dict(inv) for inv in 
                      wrapper_data.get('applicationMetaData', {}).get('inventorBag', [])],
            confirmation_number=wrapper_data.get('applicationMetaData', {}).get('applicationConfirmationNumber'),
            customer_number=wrapper_data.get('applicationMetaData', {}).get('customerNumber'),
            docket_number=wrapper_data.get('applicationMetaData', {}).get('docketNumber')
        )

    @classmethod
    def parse_response(cls, response_json: dict) -> 'PatentFileWrapper':
        """Parse the complete USPTO API response"""
        return cls.from_dict(response_json)

Functions

parse_response classmethod 

parse_response(response_json)

Parse the complete USPTO API response

Source code in src/uspto_odp/models/patent_file_wrapper.py 
158
159
160
161
@classmethod
def parse_response(cls, response_json: dict) -> 'PatentFileWrapper':
    """Parse the complete USPTO API response"""
    return cls.from_dict(response_json)

ApplicationMetadataResponse

uspto_odp.models.patent_metadata.ApplicationMetadataResponse dataclass

Response model for the /meta-data endpoint. Contains application number and metadata.

Source code in src/uspto_odp/models/patent_metadata.py 
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
@dataclass
class ApplicationMetadataResponse:
    """
    Response model for the /meta-data endpoint.
    Contains application number and metadata.
    """
    application_number: str
    metadata: ApplicationMetadata
    request_identifier: Optional[str] = None

    @classmethod
    def from_dict(cls, data: dict) -> 'ApplicationMetadataResponse':
        """
        Parse the meta-data endpoint response.

        The API returns:
        {
            "count": 1,
            "patentFileWrapperDataBag": [
                {
                    "applicationNumberText": "...",
                    "applicationMetaData": {...}
                }
            ],
            "requestIdentifier": "..."
        }
        """
        wrapper_data = data.get('patentFileWrapperDataBag', [{}])[0]

        return cls(
            application_number=wrapper_data.get('applicationNumberText', ''),
            metadata=ApplicationMetadata.from_dict(wrapper_data.get('applicationMetaData', {})),
            request_identifier=data.get('requestIdentifier')
        )

Functions

from_dict classmethod 

from_dict(data)

Parse the meta-data endpoint response.

The API returns: { "count": 1, "patentFileWrapperDataBag": [ { "applicationNumberText": "...", "applicationMetaData": {...} } ], "requestIdentifier": "..." }

Source code in src/uspto_odp/models/patent_metadata.py 
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
@classmethod
def from_dict(cls, data: dict) -> 'ApplicationMetadataResponse':
    """
    Parse the meta-data endpoint response.

    The API returns:
    {
        "count": 1,
        "patentFileWrapperDataBag": [
            {
                "applicationNumberText": "...",
                "applicationMetaData": {...}
            }
        ],
        "requestIdentifier": "..."
    }
    """
    wrapper_data = data.get('patentFileWrapperDataBag', [{}])[0]

    return cls(
        application_number=wrapper_data.get('applicationNumberText', ''),
        metadata=ApplicationMetadata.from_dict(wrapper_data.get('applicationMetaData', {})),
        request_identifier=data.get('requestIdentifier')
    )

PatentDocumentCollection

uspto_odp.models.patent_documents.PatentDocumentCollection dataclass

Collection of patent documents

Source code in src/uspto_odp/models/patent_documents.py 
79
80
81
82
83
84
85
86
87
88
@dataclass
class PatentDocumentCollection:
    """Collection of patent documents"""
    documents: List[PatentDocument] = field(default_factory=list)

    @classmethod
    def from_dict(cls, data: dict) -> 'PatentDocumentCollection':
        return cls(
            documents=[PatentDocument.from_dict(doc) for doc in data.get('documentBag', [])]
        )

ContinuityCollection

uspto_odp.models.patent_continuity.ContinuityCollection dataclass

Collection of continuity data

Source code in src/uspto_odp/models/patent_continuity.py 
115
116
117
118
119
120
121
122
123
124
125
126
@dataclass
class ContinuityCollection:
    """Collection of continuity data"""
    count: int
    continuities: List[ContinuityData] = field(default_factory=list)

    @classmethod
    def from_dict(cls, data: dict) -> 'ContinuityCollection':
        return cls(
            count=data['count'],
            continuities=[ContinuityData.from_dict(pw) for pw in data.get('patentFileWrapperDataBag', [])]
        )

ForeignPriorityCollection

uspto_odp.models.foreign_priority.ForeignPriorityCollection dataclass

Collection of foreign priority data

Source code in src/uspto_odp/models/foreign_priority.py 
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
@dataclass
class ForeignPriorityCollection:
    """Collection of foreign priority data"""
    count: int
    priorities: List[ForeignPriorityData] = field(default_factory=list)

    @classmethod
    def from_dict(cls, data: dict) -> 'ForeignPriorityCollection':
        return cls(
            count=data.get('count', 0),
            priorities=[
                ForeignPriorityData.from_dict(pw) 
                for pw in data.get('patentFileWrapperDataBag', [])
            ]
        )

TransactionCollection

uspto_odp.models.patent_transactions.TransactionCollection dataclass

Collection of transaction data

Source code in src/uspto_odp/models/patent_transactions.py 
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
@dataclass
class TransactionCollection:
    """Collection of transaction data"""
    count: int
    transactions: List[ApplicationTransactions] = field(default_factory=list)
    request_identifier: Optional[str] = None

    @classmethod
    def from_dict(cls, data: dict) -> 'TransactionCollection':
        return cls(
            count=data.get('count', 0),
            transactions=[ApplicationTransactions.from_dict(pw) 
                         for pw in data.get('patentFileWrapperDataBag', [])],
            request_identifier=data.get('requestIdentifier')
        )

AssignmentCollection

uspto_odp.models.patent_assignment.AssignmentCollection dataclass

Collection of assignment data

Source code in src/uspto_odp/models/patent_assignment.py 
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
@dataclass
class AssignmentCollection:
    """Collection of assignment data"""
    count: int
    assignments: List[ApplicationAssignment] = field(default_factory=list)
    request_identifier: Optional[str] = None

    @classmethod
    def from_dict(cls, data: dict) -> 'AssignmentCollection':
        return cls(
            count=data.get('count', 0),
            assignments=[ApplicationAssignment.from_dict(pw) 
                        for pw in data.get('patentFileWrapperDataBag', [])],
            request_identifier=data.get('requestIdentifier')
        )

AttorneyResponse

uspto_odp.models.patent_attorney.AttorneyResponse dataclass

Response model for the /attorney endpoint

Source code in src/uspto_odp/models/patent_attorney.py 
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
@dataclass
class AttorneyResponse:
    """Response model for the /attorney endpoint"""
    count: int
    attorneys: List[ApplicationAttorney] = field(default_factory=list)
    request_identifier: Optional[str] = None

    @classmethod
    def from_dict(cls, data: dict) -> 'AttorneyResponse':
        """
        Parse the attorney endpoint response.

        The API returns:
        {
            "count": 1,
            "patentFileWrapperDataBag": [
                {
                    "applicationNumberText": "...",
                    "recordAttorney": {...}
                }
            ],
            "requestIdentifier": "..."
        }
        """
        return cls(
            count=data.get('count', 0),
            attorneys=[ApplicationAttorney.from_dict(pw) 
                      for pw in data.get('patentFileWrapperDataBag', [])],
            request_identifier=data.get('requestIdentifier')
        )

Functions

from_dict classmethod 

from_dict(data)

Parse the attorney endpoint response.

The API returns: { "count": 1, "patentFileWrapperDataBag": [ { "applicationNumberText": "...", "recordAttorney": {...} } ], "requestIdentifier": "..." }

Source code in src/uspto_odp/models/patent_attorney.py 
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
@classmethod
def from_dict(cls, data: dict) -> 'AttorneyResponse':
    """
    Parse the attorney endpoint response.

    The API returns:
    {
        "count": 1,
        "patentFileWrapperDataBag": [
            {
                "applicationNumberText": "...",
                "recordAttorney": {...}
            }
        ],
        "requestIdentifier": "..."
    }
    """
    return cls(
        count=data.get('count', 0),
        attorneys=[ApplicationAttorney.from_dict(pw) 
                  for pw in data.get('patentFileWrapperDataBag', [])],
        request_identifier=data.get('requestIdentifier')
    )

AdjustmentResponse

uspto_odp.models.patent_adjustment.AdjustmentResponse dataclass

Response model for the /adjustment endpoint

Source code in src/uspto_odp/models/patent_adjustment.py 
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
@dataclass
class AdjustmentResponse:
    """Response model for the /adjustment endpoint"""
    count: int
    adjustments: List[ApplicationAdjustment] = field(default_factory=list)
    request_identifier: Optional[str] = None

    @classmethod
    def from_dict(cls, data: dict) -> 'AdjustmentResponse':
        """
        Parse the adjustment endpoint response.

        The API returns:
        {
            "count": 1,
            "patentFileWrapperDataBag": [
                {
                    "applicationNumberText": "...",
                    "patentTermAdjustmentData": {...}
                }
            ],
            "requestIdentifier": "..."
        }
        """
        return cls(
            count=data.get('count', 0),
            adjustments=[ApplicationAdjustment.from_dict(pw) 
                        for pw in data.get('patentFileWrapperDataBag', [])],
            request_identifier=data.get('requestIdentifier')
        )

Functions

from_dict classmethod 

from_dict(data)

Parse the adjustment endpoint response.

The API returns: { "count": 1, "patentFileWrapperDataBag": [ { "applicationNumberText": "...", "patentTermAdjustmentData": {...} } ], "requestIdentifier": "..." }

Source code in src/uspto_odp/models/patent_adjustment.py 
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
@classmethod
def from_dict(cls, data: dict) -> 'AdjustmentResponse':
    """
    Parse the adjustment endpoint response.

    The API returns:
    {
        "count": 1,
        "patentFileWrapperDataBag": [
            {
                "applicationNumberText": "...",
                "patentTermAdjustmentData": {...}
            }
        ],
        "requestIdentifier": "..."
    }
    """
    return cls(
        count=data.get('count', 0),
        adjustments=[ApplicationAdjustment.from_dict(pw) 
                    for pw in data.get('patentFileWrapperDataBag', [])],
        request_identifier=data.get('requestIdentifier')
    )

AssociatedDocumentsResponse

uspto_odp.models.patent_associated_documents.AssociatedDocumentsResponse dataclass

Response model for the /associated-documents endpoint

Source code in src/uspto_odp/models/patent_associated_documents.py 
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
@dataclass
class AssociatedDocumentsResponse:
    """Response model for the /associated-documents endpoint"""
    count: int
    associated_documents: list[ApplicationAssociatedDocuments] = field(default_factory=list)
    request_identifier: Optional[str] = None

    @classmethod
    def from_dict(cls, data: dict) -> 'AssociatedDocumentsResponse':
        """
        Parse the associated-documents endpoint response.

        The API returns:
        {
            "count": 1,
            "patentFileWrapperDataBag": [
                {
                    "applicationNumberText": "...",
                    "pgpubDocumentMetaData": {...},
                    "grantDocumentMetaData": {...},
                    "requestIdentifier": "..."
                }
            ],
            "requestIdentifier": "..." (optional at top level)
        }
        """
        return cls(
            count=data.get('count', 0),
            associated_documents=[ApplicationAssociatedDocuments.from_dict(pw) 
                                for pw in data.get('patentFileWrapperDataBag', [])],
            request_identifier=data.get('requestIdentifier')
        )

Functions

from_dict classmethod 

from_dict(data)

Parse the associated-documents endpoint response.

The API returns: { "count": 1, "patentFileWrapperDataBag": [ { "applicationNumberText": "...", "pgpubDocumentMetaData": {...}, "grantDocumentMetaData": {...}, "requestIdentifier": "..." } ], "requestIdentifier": "..." (optional at top level) }

Source code in src/uspto_odp/models/patent_associated_documents.py 
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
@classmethod
def from_dict(cls, data: dict) -> 'AssociatedDocumentsResponse':
    """
    Parse the associated-documents endpoint response.

    The API returns:
    {
        "count": 1,
        "patentFileWrapperDataBag": [
            {
                "applicationNumberText": "...",
                "pgpubDocumentMetaData": {...},
                "grantDocumentMetaData": {...},
                "requestIdentifier": "..."
            }
        ],
        "requestIdentifier": "..." (optional at top level)
    }
    """
    return cls(
        count=data.get('count', 0),
        associated_documents=[ApplicationAssociatedDocuments.from_dict(pw) 
                            for pw in data.get('patentFileWrapperDataBag', [])],
        request_identifier=data.get('requestIdentifier')
    )

StatusCodeCollection

uspto_odp.models.patent_status_codes.StatusCodeCollection dataclass

Collection of patent application status codes returned from search.

Attributes:

Name Type Description
count int

Total number of status codes matching the search criteria
status_codes List[StatusCode]

List of StatusCode objects
request_identifier Optional[str]

Optional request identifier from the API
Source code in src/uspto_odp/models/patent_status_codes.py 
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
@dataclass
class StatusCodeCollection:
    """
    Collection of patent application status codes returned from search.

    Attributes:
        count: Total number of status codes matching the search criteria
        status_codes: List of StatusCode objects
        request_identifier: Optional request identifier from the API
    """
    count: int
    status_codes: List[StatusCode] = field(default_factory=list)
    request_identifier: Optional[str] = None

    @classmethod
    def from_dict(cls, data: dict) -> 'StatusCodeCollection':
        """
        Create a StatusCodeCollection instance from a dictionary.

        Args:
            data: Dictionary containing status code collection data from API response

        Returns:
            StatusCodeCollection instance
        """
        return cls(
            count=data.get('count', 0),
            status_codes=[StatusCode.from_dict(sc) 
                         for sc in data.get('statusCodeDataBag', [])],
            request_identifier=data.get('requestIdentifier')
        )

Functions

from_dict classmethod 

from_dict(data)

Create a StatusCodeCollection instance from a dictionary.

Parameters:

Name Type Description Default
data dict

Dictionary containing status code collection data from API response

 required

Returns:

Type Description
StatusCodeCollection

StatusCodeCollection instance
Source code in src/uspto_odp/models/patent_status_codes.py 
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
@classmethod
def from_dict(cls, data: dict) -> 'StatusCodeCollection':
    """
    Create a StatusCodeCollection instance from a dictionary.

    Args:
        data: Dictionary containing status code collection data from API response

    Returns:
        StatusCodeCollection instance
    """
    return cls(
        count=data.get('count', 0),
        status_codes=[StatusCode.from_dict(sc) 
                     for sc in data.get('statusCodeDataBag', [])],
        request_identifier=data.get('requestIdentifier')
    )

Petition Decision Models

PetitionDecisionResponseBag

uspto_odp.models.patent_petition_decision.PetitionDecisionResponseBag dataclass

Response container for petition decision search results.

Source code in src/uspto_odp/models/patent_petition_decision.py 
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
@dataclass
class PetitionDecisionResponseBag:
    """
    Response container for petition decision search results.
    """
    count: int = 0
    petition_decision_bag: List[PetitionDecision] = field(default_factory=list)
    request_identifier: Optional[str] = None
    facets: Optional[Dict[str, Any]] = None

    @classmethod
    def from_dict(cls, data: dict) -> 'PetitionDecisionResponseBag':
        """
        Parse the search response data into a PetitionDecisionResponseBag object.

        Args:
            data (dict): The raw JSON response from the API

        Returns:
            PetitionDecisionResponseBag: A structured representation of the search results
        """
        result = cls(
            count=data.get('count', 0),
            request_identifier=data.get('requestIdentifier'),
            facets=data.get('facets')
        )

        # Parse petition decision bag
        if 'petitionDecisionBag' in data:
            result.petition_decision_bag = [
                PetitionDecision.from_dict(decision_data)
                for decision_data in data['petitionDecisionBag']
            ]

        return result

Functions

from_dict classmethod 

from_dict(data)

Parse the search response data into a PetitionDecisionResponseBag object.

Parameters:

Name Type Description Default
data dict

The raw JSON response from the API

 required

Returns:

Name Type Description
PetitionDecisionResponseBag PetitionDecisionResponseBag

A structured representation of the search results
Source code in src/uspto_odp/models/patent_petition_decision.py 
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
@classmethod
def from_dict(cls, data: dict) -> 'PetitionDecisionResponseBag':
    """
    Parse the search response data into a PetitionDecisionResponseBag object.

    Args:
        data (dict): The raw JSON response from the API

    Returns:
        PetitionDecisionResponseBag: A structured representation of the search results
    """
    result = cls(
        count=data.get('count', 0),
        request_identifier=data.get('requestIdentifier'),
        facets=data.get('facets')
    )

    # Parse petition decision bag
    if 'petitionDecisionBag' in data:
        result.petition_decision_bag = [
            PetitionDecision.from_dict(decision_data)
            for decision_data in data['petitionDecisionBag']
        ]

    return result

PTAB Trials Models

TrialProceedingResponseBag

uspto_odp.models.patent_trials_proceedings.TrialProceedingResponseBag dataclass

Response container for trial proceeding search results.

Source code in src/uspto_odp/models/patent_trials_proceedings.py 
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
@dataclass
class TrialProceedingResponseBag:
    """
    Response container for trial proceeding search results.
    """
    count: int = 0
    trial_proceeding_bag: List[TrialProceeding] = field(default_factory=list)
    request_identifier: Optional[str] = None
    facets: Optional[Dict[str, Any]] = None

    @classmethod
    def from_dict(cls, data: dict) -> 'TrialProceedingResponseBag':
        """
        Parse the search response data into a TrialProceedingResponseBag object.

        Args:
            data (dict): The raw JSON response from the API

        Returns:
            TrialProceedingResponseBag: A structured representation of the search results
        """
        result = cls(
            count=data.get('count', 0),
            request_identifier=data.get('requestIdentifier'),
            facets=data.get('facets')
        )

        # Parse trial proceeding bag
        if 'trialProceedingBag' in data:
            result.trial_proceeding_bag = [
                TrialProceeding.from_dict(proceeding_data)
                for proceeding_data in data['trialProceedingBag']
            ]

        return result

Functions

from_dict classmethod 

from_dict(data)

Parse the search response data into a TrialProceedingResponseBag object.

Parameters:

Name Type Description Default
data dict

The raw JSON response from the API

 required

Returns:

Name Type Description
TrialProceedingResponseBag TrialProceedingResponseBag

A structured representation of the search results
Source code in src/uspto_odp/models/patent_trials_proceedings.py 
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
@classmethod
def from_dict(cls, data: dict) -> 'TrialProceedingResponseBag':
    """
    Parse the search response data into a TrialProceedingResponseBag object.

    Args:
        data (dict): The raw JSON response from the API

    Returns:
        TrialProceedingResponseBag: A structured representation of the search results
    """
    result = cls(
        count=data.get('count', 0),
        request_identifier=data.get('requestIdentifier'),
        facets=data.get('facets')
    )

    # Parse trial proceeding bag
    if 'trialProceedingBag' in data:
        result.trial_proceeding_bag = [
            TrialProceeding.from_dict(proceeding_data)
            for proceeding_data in data['trialProceedingBag']
        ]

    return result

TrialDecisionResponseBag

uspto_odp.models.patent_trials_decisions.TrialDecisionResponseBag dataclass

Response container for trial decision search results.

Source code in src/uspto_odp/models/patent_trials_decisions.py 
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
@dataclass
class TrialDecisionResponseBag:
    """
    Response container for trial decision search results.
    """
    count: int = 0
    trial_decision_bag: List[TrialDecision] = field(default_factory=list)
    request_identifier: Optional[str] = None
    facets: Optional[Dict[str, Any]] = None

    @classmethod
    def from_dict(cls, data: dict) -> 'TrialDecisionResponseBag':
        """
        Parse the search response data into a TrialDecisionResponseBag object.

        Args:
            data (dict): The raw JSON response from the API

        Returns:
            TrialDecisionResponseBag: A structured representation of the search results
        """
        result = cls(
            count=data.get('count', 0),
            request_identifier=data.get('requestIdentifier'),
            facets=data.get('facets')
        )

        # Parse trial decision bag (API uses camelCase: trialDecisionBag)
        if 'trialDecisionBag' in data:
            result.trial_decision_bag = [
                TrialDecision.from_dict(decision_data)
                for decision_data in data['trialDecisionBag']
            ]

        return result

Functions

from_dict classmethod 

from_dict(data)

Parse the search response data into a TrialDecisionResponseBag object.

Parameters:

Name Type Description Default
data dict

The raw JSON response from the API

 required

Returns:

Name Type Description
TrialDecisionResponseBag TrialDecisionResponseBag

A structured representation of the search results
Source code in src/uspto_odp/models/patent_trials_decisions.py 
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
@classmethod
def from_dict(cls, data: dict) -> 'TrialDecisionResponseBag':
    """
    Parse the search response data into a TrialDecisionResponseBag object.

    Args:
        data (dict): The raw JSON response from the API

    Returns:
        TrialDecisionResponseBag: A structured representation of the search results
    """
    result = cls(
        count=data.get('count', 0),
        request_identifier=data.get('requestIdentifier'),
        facets=data.get('facets')
    )

    # Parse trial decision bag (API uses camelCase: trialDecisionBag)
    if 'trialDecisionBag' in data:
        result.trial_decision_bag = [
            TrialDecision.from_dict(decision_data)
            for decision_data in data['trialDecisionBag']
        ]

    return result

TrialDocumentResponseBag

uspto_odp.models.patent_trials_documents.TrialDocumentResponseBag dataclass

Response container for trial document search results.

Source code in src/uspto_odp/models/patent_trials_documents.py 
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
@dataclass
class TrialDocumentResponseBag:
    """
    Response container for trial document search results.
    """
    count: int = 0
    trial_document_bag: List[TrialDocument] = field(default_factory=list)
    request_identifier: Optional[str] = None
    facets: Optional[Dict[str, Any]] = None

    @classmethod
    def from_dict(cls, data: dict) -> 'TrialDocumentResponseBag':
        """
        Parse the search response data into a TrialDocumentResponseBag object.

        Args:
            data (dict): The raw JSON response from the API

        Returns:
            TrialDocumentResponseBag: A structured representation of the search results
        """
        result = cls(
            count=data.get('count', 0),
            request_identifier=data.get('requestIdentifier'),
            facets=data.get('facets')
        )

        # Parse trial document bag (API uses camelCase: trialDocumentBag)
        if 'trialDocumentBag' in data:
            result.trial_document_bag = [
                TrialDocument.from_dict(document_data)
                for document_data in data['trialDocumentBag']
            ]

        return result

Functions

from_dict classmethod 

from_dict(data)

Parse the search response data into a TrialDocumentResponseBag object.

Parameters:

Name Type Description Default
data dict

The raw JSON response from the API

 required

Returns:

Name Type Description
TrialDocumentResponseBag TrialDocumentResponseBag

A structured representation of the search results
Source code in src/uspto_odp/models/patent_trials_documents.py 
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
@classmethod
def from_dict(cls, data: dict) -> 'TrialDocumentResponseBag':
    """
    Parse the search response data into a TrialDocumentResponseBag object.

    Args:
        data (dict): The raw JSON response from the API

    Returns:
        TrialDocumentResponseBag: A structured representation of the search results
    """
    result = cls(
        count=data.get('count', 0),
        request_identifier=data.get('requestIdentifier'),
        facets=data.get('facets')
    )

    # Parse trial document bag (API uses camelCase: trialDocumentBag)
    if 'trialDocumentBag' in data:
        result.trial_document_bag = [
            TrialDocument.from_dict(document_data)
            for document_data in data['trialDocumentBag']
        ]

    return result

PTAB Appeals Models

AppealDecisionResponseBag

uspto_odp.models.patent_appeals_decisions.AppealDecisionResponseBag dataclass

Response container for appeal decision search results.

Source code in src/uspto_odp/models/patent_appeals_decisions.py 
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
@dataclass
class AppealDecisionResponseBag:
    """
    Response container for appeal decision search results.
    """
    count: int = 0
    appeal_decision_bag: List[AppealDecision] = field(default_factory=list)
    request_identifier: Optional[str] = None
    facets: Optional[Dict[str, Any]] = None

    @classmethod
    def from_dict(cls, data: dict) -> 'AppealDecisionResponseBag':
        """
        Parse the search response data into an AppealDecisionResponseBag object.

        Args:
            data (dict): The raw JSON response from the API

        Returns:
            AppealDecisionResponseBag: A structured representation of the search results
        """
        result = cls(
            count=data.get('count', 0),
            request_identifier=data.get('requestIdentifier'),
            facets=data.get('facets')
        )

        # Parse appeal decision bag (API uses camelCase: appealDecisionBag)
        if 'appealDecisionBag' in data:
            result.appeal_decision_bag = [
                AppealDecision.from_dict(decision_data)
                for decision_data in data['appealDecisionBag']
            ]

        return result

Functions

from_dict classmethod 

from_dict(data)

Parse the search response data into an AppealDecisionResponseBag object.

Parameters:

Name Type Description Default
data dict

The raw JSON response from the API

 required

Returns:

Name Type Description
AppealDecisionResponseBag AppealDecisionResponseBag

A structured representation of the search results
Source code in src/uspto_odp/models/patent_appeals_decisions.py 
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
@classmethod
def from_dict(cls, data: dict) -> 'AppealDecisionResponseBag':
    """
    Parse the search response data into an AppealDecisionResponseBag object.

    Args:
        data (dict): The raw JSON response from the API

    Returns:
        AppealDecisionResponseBag: A structured representation of the search results
    """
    result = cls(
        count=data.get('count', 0),
        request_identifier=data.get('requestIdentifier'),
        facets=data.get('facets')
    )

    # Parse appeal decision bag (API uses camelCase: appealDecisionBag)
    if 'appealDecisionBag' in data:
        result.appeal_decision_bag = [
            AppealDecision.from_dict(decision_data)
            for decision_data in data['appealDecisionBag']
        ]

    return result

PTAB Interferences Models

InterferenceDecisionResponseBag

uspto_odp.models.patent_interferences_decisions.InterferenceDecisionResponseBag dataclass

Response container for interference decision search results.

Source code in src/uspto_odp/models/patent_interferences_decisions.py 
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
@dataclass
class InterferenceDecisionResponseBag:
    """
    Response container for interference decision search results.
    """
    count: int = 0
    interference_decision_bag: List[InterferenceDecision] = field(default_factory=list)
    request_identifier: Optional[str] = None
    facets: Optional[Dict[str, Any]] = None

    @classmethod
    def from_dict(cls, data: dict) -> 'InterferenceDecisionResponseBag':
        """
        Parse the search response data into an InterferenceDecisionResponseBag object.

        Args:
            data (dict): The raw JSON response from the API

        Returns:
            InterferenceDecisionResponseBag: A structured representation of the search results
        """
        result = cls(
            count=data.get('count', 0),
            request_identifier=data.get('requestIdentifier'),
            facets=data.get('facets')
        )

        # Parse interference decision bag (API uses camelCase: interferenceDecisionBag)
        if 'interferenceDecisionBag' in data:
            result.interference_decision_bag = [
                InterferenceDecision.from_dict(decision_data)
                for decision_data in data['interferenceDecisionBag']
            ]

        return result

Functions

from_dict classmethod 

from_dict(data)

Parse the search response data into an InterferenceDecisionResponseBag object.

Parameters:

Name Type Description Default
data dict

The raw JSON response from the API

 required

Returns:

Name Type Description
InterferenceDecisionResponseBag InterferenceDecisionResponseBag

A structured representation of the search results
Source code in src/uspto_odp/models/patent_interferences_decisions.py 
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
@classmethod
def from_dict(cls, data: dict) -> 'InterferenceDecisionResponseBag':
    """
    Parse the search response data into an InterferenceDecisionResponseBag object.

    Args:
        data (dict): The raw JSON response from the API

    Returns:
        InterferenceDecisionResponseBag: A structured representation of the search results
    """
    result = cls(
        count=data.get('count', 0),
        request_identifier=data.get('requestIdentifier'),
        facets=data.get('facets')
    )

    # Parse interference decision bag (API uses camelCase: interferenceDecisionBag)
    if 'interferenceDecisionBag' in data:
        result.interference_decision_bag = [
            InterferenceDecision.from_dict(decision_data)
            for decision_data in data['interferenceDecisionBag']
        ]

    return result

Bulk Datasets Models

DatasetProductSearchResponseBag

uspto_odp.models.bulk_datasets.DatasetProductSearchResponseBag dataclass

Response container for dataset product search results.

Source code in src/uspto_odp/models/bulk_datasets.py 
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
@dataclass
class DatasetProductSearchResponseBag:
    """
    Response container for dataset product search results.
    """
    count: int = 0
    dataset_product_bag: List[DatasetProduct] = field(default_factory=list)
    request_identifier: Optional[str] = None
    facets: Optional[Dict[str, Any]] = None

    @classmethod
    def from_dict(cls, data: dict) -> 'DatasetProductSearchResponseBag':
        """
        Parse the search response data into a DatasetProductSearchResponseBag object.

        Args:
            data (dict): The raw JSON response from the API

        Returns:
            DatasetProductSearchResponseBag: A structured representation of the search results
        """
        result = cls(
            count=data.get('count', 0),
            request_identifier=data.get('requestIdentifier'),
            facets=data.get('facets')
        )

        # Parse dataset product bag (API uses camelCase: datasetProductBag)
        if 'datasetProductBag' in data:
            result.dataset_product_bag = [
                DatasetProduct.from_dict(product_data)
                for product_data in data['datasetProductBag']
            ]
        elif 'productBag' in data:
            # Alternative field name
            result.dataset_product_bag = [
                DatasetProduct.from_dict(product_data)
                for product_data in data['productBag']
            ]

        return result

Functions

from_dict classmethod 

from_dict(data)

Parse the search response data into a DatasetProductSearchResponseBag object.

Parameters:

Name Type Description Default
data dict

The raw JSON response from the API

 required

Returns:

Name Type Description
DatasetProductSearchResponseBag DatasetProductSearchResponseBag

A structured representation of the search results
Source code in src/uspto_odp/models/bulk_datasets.py 
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
@classmethod
def from_dict(cls, data: dict) -> 'DatasetProductSearchResponseBag':
    """
    Parse the search response data into a DatasetProductSearchResponseBag object.

    Args:
        data (dict): The raw JSON response from the API

    Returns:
        DatasetProductSearchResponseBag: A structured representation of the search results
    """
    result = cls(
        count=data.get('count', 0),
        request_identifier=data.get('requestIdentifier'),
        facets=data.get('facets')
    )

    # Parse dataset product bag (API uses camelCase: datasetProductBag)
    if 'datasetProductBag' in data:
        result.dataset_product_bag = [
            DatasetProduct.from_dict(product_data)
            for product_data in data['datasetProductBag']
        ]
    elif 'productBag' in data:
        # Alternative field name
        result.dataset_product_bag = [
            DatasetProduct.from_dict(product_data)
            for product_data in data['productBag']
        ]

    return result

DatasetProductResponseBag

uspto_odp.models.bulk_datasets.DatasetProductResponseBag dataclass

Response container for individual dataset product lookup by product identifier. Similar to DatasetProductSearchResponseBag but for single record retrieval.

Source code in src/uspto_odp/models/bulk_datasets.py 
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
@dataclass
class DatasetProductResponseBag:
    """
    Response container for individual dataset product lookup by product identifier.
    Similar to DatasetProductSearchResponseBag but for single record retrieval.
    """
    count: int = 0
    dataset_product_bag: List[DatasetProduct] = field(default_factory=list)
    request_identifier: Optional[str] = None

    @classmethod
    def from_dict(cls, data: dict) -> 'DatasetProductResponseBag':
        """
        Parse the individual dataset product response by product identifier.

        Args:
            data (dict): The raw JSON response from the API

        Returns:
            DatasetProductResponseBag: A structured representation of the dataset product
        """
        result = cls(
            count=data.get('count', 0),
            request_identifier=data.get('requestIdentifier')
        )

        # Parse dataset product bag (typically contains one record)
        if 'datasetProductBag' in data:
            result.dataset_product_bag = [
                DatasetProduct.from_dict(product_data)
                for product_data in data['datasetProductBag']
            ]
        elif 'productBag' in data:
            # Alternative field name
            result.dataset_product_bag = [
                DatasetProduct.from_dict(product_data)
                for product_data in data['productBag']
            ]
        elif 'product' in data:
            # Single product object
            result.dataset_product_bag = [DatasetProduct.from_dict(data['product'])]
            result.count = 1

        return result

Functions

from_dict classmethod 

from_dict(data)

Parse the individual dataset product response by product identifier.

Parameters:

Name Type Description Default
data dict

The raw JSON response from the API

 required

Returns:

Name Type Description
DatasetProductResponseBag DatasetProductResponseBag

A structured representation of the dataset product
Source code in src/uspto_odp/models/bulk_datasets.py 
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
@classmethod
def from_dict(cls, data: dict) -> 'DatasetProductResponseBag':
    """
    Parse the individual dataset product response by product identifier.

    Args:
        data (dict): The raw JSON response from the API

    Returns:
        DatasetProductResponseBag: A structured representation of the dataset product
    """
    result = cls(
        count=data.get('count', 0),
        request_identifier=data.get('requestIdentifier')
    )

    # Parse dataset product bag (typically contains one record)
    if 'datasetProductBag' in data:
        result.dataset_product_bag = [
            DatasetProduct.from_dict(product_data)
            for product_data in data['datasetProductBag']
        ]
    elif 'productBag' in data:
        # Alternative field name
        result.dataset_product_bag = [
            DatasetProduct.from_dict(product_data)
            for product_data in data['productBag']
        ]
    elif 'product' in data:
        # Single product object
        result.dataset_product_bag = [DatasetProduct.from_dict(data['product'])]
        result.count = 1

    return result

DatasetFileResponseBag

uspto_odp.models.bulk_datasets.DatasetFileResponseBag dataclass

Response container for dataset file download. This may contain file metadata or binary data information.

Source code in src/uspto_odp/models/bulk_datasets.py 
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
@dataclass
class DatasetFileResponseBag:
    """
    Response container for dataset file download.
    This may contain file metadata or binary data information.
    """
    file_name: Optional[str] = None
    file_url: Optional[str] = None
    file_size: Optional[int] = None
    content_type: Optional[str] = None
    download_url: Optional[str] = None
    request_identifier: Optional[str] = None
    # Additional metadata
    metadata: Optional[Dict[str, Any]] = None

    @classmethod
    def from_dict(cls, data: dict) -> 'DatasetFileResponseBag':
        """
        Parse the dataset file response.

        Args:
            data (dict): The raw JSON response from the API

        Returns:
            DatasetFileResponseBag: A structured representation of the file response
        """
        return cls(
            file_name=data.get('fileName') or data.get('filename'),
            file_url=data.get('fileUrl') or data.get('file_url'),
            file_size=data.get('fileSize') or data.get('file_size'),
            content_type=data.get('contentType') or data.get('content_type'),
            download_url=data.get('downloadUrl') or data.get('download_url'),
            request_identifier=data.get('requestIdentifier'),
            metadata=data.get('metadata')
        )

Functions

from_dict classmethod 

from_dict(data)

Parse the dataset file response.

Parameters:

Name Type Description Default
data dict

The raw JSON response from the API

 required

Returns:

Name Type Description
DatasetFileResponseBag DatasetFileResponseBag

A structured representation of the file response
Source code in src/uspto_odp/models/bulk_datasets.py 
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
@classmethod
def from_dict(cls, data: dict) -> 'DatasetFileResponseBag':
    """
    Parse the dataset file response.

    Args:
        data (dict): The raw JSON response from the API

    Returns:
        DatasetFileResponseBag: A structured representation of the file response
    """
    return cls(
        file_name=data.get('fileName') or data.get('filename'),
        file_url=data.get('fileUrl') or data.get('file_url'),
        file_size=data.get('fileSize') or data.get('file_size'),
        content_type=data.get('contentType') or data.get('content_type'),
        download_url=data.get('downloadUrl') or data.get('download_url'),
        request_identifier=data.get('requestIdentifier'),
        metadata=data.get('metadata')
    )