bely-api 2026.3.dev3__tar.gz → 2026.3.dev4__tar.gz

{bely_api-2026.3.dev3 → bely_api-2026.3.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bely_api
-Version: 2026.3.dev3
+Version: 2026.3.dev4
 Summary: Python client API library used to communicate with BELY API.
 Home-page: https://git.aps.anl.gov/controls/hla/bely
 Maintainer: Dariusz Jarosz

{bely_api-2026.3.dev3 → bely_api-2026.3.dev4}/belyApi/__init__.py

@@ -66,6 +66,7 @@ __all__ = [
     "LogDocumentOptions",
     "LogDocumentSection",
     "LogEntry",
+    "LogEntryAttachment",
     "LogReaction",
     "LogbookSearchResults",
     "NotificationConfiguration",
@@ -145,6 +146,7 @@ from belyApi.models.log import Log as Log
 from belyApi.models.log_document_options import LogDocumentOptions as LogDocumentOptions
 from belyApi.models.log_document_section import LogDocumentSection as LogDocumentSection
 from belyApi.models.log_entry import LogEntry as LogEntry
+from belyApi.models.log_entry_attachment import LogEntryAttachment as LogEntryAttachment
 from belyApi.models.log_reaction import LogReaction as LogReaction
 from belyApi.models.logbook_search_results import LogbookSearchResults as LogbookSearchResults
 from belyApi.models.notification_configuration import NotificationConfiguration as NotificationConfiguration

{bely_api-2026.3.dev3 → bely_api-2026.3.dev4}/belyApi/api/logbook_api.py

@@ -16,8 +16,8 @@ from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
 from typing import Any, Dict, List, Optional, Tuple, Union
 from typing_extensions import Annotated
 
-from pydantic import Field, StrictBool, StrictInt, StrictStr
-from typing import List, Optional
+from pydantic import Field, StrictBool, StrictBytes, StrictInt, StrictStr
+from typing import List, Optional, Tuple, Union
 from typing_extensions import Annotated
 from belyApi.models.entity_type import EntityType
 from belyApi.models.item_domain_logbook import ItemDomainLogbook
@@ -25,6 +25,7 @@ from belyApi.models.item_type import ItemType
 from belyApi.models.log_document_options import LogDocumentOptions
 from belyApi.models.log_document_section import LogDocumentSection
 from belyApi.models.log_entry import LogEntry
+from belyApi.models.log_entry_attachment import LogEntryAttachment
 
 from belyApi.api_client import ApiClient, RequestSerialized
 from belyApi.api_response import ApiResponse
@@ -1422,6 +1423,278 @@ class LogbookApi:
 
 
 
+    @validate_call
+    def get_log_entry_attachments(
+        self,
+        log_document_id: StrictInt,
+        log_id: StrictInt,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> List[LogEntryAttachment]:
+        """Fetch attachments for a log entry.
+
+
+        :param log_document_id: (required)
+        :type log_document_id: int
+        :param log_id: (required)
+        :type log_id: int
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_log_entry_attachments_serialize(
+            log_document_id=log_document_id,
+            log_id=log_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "List[LogEntryAttachment]",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def get_log_entry_attachments_with_http_info(
+        self,
+        log_document_id: StrictInt,
+        log_id: StrictInt,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[List[LogEntryAttachment]]:
+        """Fetch attachments for a log entry.
+
+
+        :param log_document_id: (required)
+        :type log_document_id: int
+        :param log_id: (required)
+        :type log_id: int
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_log_entry_attachments_serialize(
+            log_document_id=log_document_id,
+            log_id=log_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "List[LogEntryAttachment]",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def get_log_entry_attachments_without_preload_content(
+        self,
+        log_document_id: StrictInt,
+        log_id: StrictInt,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Fetch attachments for a log entry.
+
+
+        :param log_document_id: (required)
+        :type log_document_id: int
+        :param log_id: (required)
+        :type log_id: int
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_log_entry_attachments_serialize(
+            log_document_id=log_document_id,
+            log_id=log_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "List[LogEntryAttachment]",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_log_entry_attachments_serialize(
+        self,
+        log_document_id,
+        log_id,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if log_document_id is not None:
+            _path_params['logDocumentId'] = log_document_id
+        if log_id is not None:
+            _path_params['logId'] = log_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/api/Logbook/LogEntryAttachments/{logDocumentId}/{logId}',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
     @validate_call
     def get_log_entry_template(
         self,
@@ -2661,3 +2934,346 @@ class LogbookApi:
         )
 
 
+
+
+    @validate_call
+    def upload_attachment(
+        self,
+        log_document_id: StrictInt,
+        log_id: StrictInt,
+        body: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="File content")],
+        append_reference: Optional[StrictBool] = None,
+        file_name: Optional[StrictStr] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> LogEntryAttachment:
+        """Upload an attachment to a log entry.
+
+
+        :param log_document_id: (required)
+        :type log_document_id: int
+        :param log_id: (required)
+        :type log_id: int
+        :param body: File content (required)
+        :type body: bytearray
+        :param append_reference:
+        :type append_reference: bool
+        :param file_name:
+        :type file_name: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._upload_attachment_serialize(
+            log_document_id=log_document_id,
+            log_id=log_id,
+            body=body,
+            append_reference=append_reference,
+            file_name=file_name,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "LogEntryAttachment",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def upload_attachment_with_http_info(
+        self,
+        log_document_id: StrictInt,
+        log_id: StrictInt,
+        body: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="File content")],
+        append_reference: Optional[StrictBool] = None,
+        file_name: Optional[StrictStr] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[LogEntryAttachment]:
+        """Upload an attachment to a log entry.
+
+
+        :param log_document_id: (required)
+        :type log_document_id: int
+        :param log_id: (required)
+        :type log_id: int
+        :param body: File content (required)
+        :type body: bytearray
+        :param append_reference:
+        :type append_reference: bool
+        :param file_name:
+        :type file_name: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._upload_attachment_serialize(
+            log_document_id=log_document_id,
+            log_id=log_id,
+            body=body,
+            append_reference=append_reference,
+            file_name=file_name,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "LogEntryAttachment",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def upload_attachment_without_preload_content(
+        self,
+        log_document_id: StrictInt,
+        log_id: StrictInt,
+        body: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="File content")],
+        append_reference: Optional[StrictBool] = None,
+        file_name: Optional[StrictStr] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Upload an attachment to a log entry.
+
+
+        :param log_document_id: (required)
+        :type log_document_id: int
+        :param log_id: (required)
+        :type log_id: int
+        :param body: File content (required)
+        :type body: bytearray
+        :param append_reference:
+        :type append_reference: bool
+        :param file_name:
+        :type file_name: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._upload_attachment_serialize(
+            log_document_id=log_document_id,
+            log_id=log_id,
+            body=body,
+            append_reference=append_reference,
+            file_name=file_name,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "LogEntryAttachment",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _upload_attachment_serialize(
+        self,
+        log_document_id,
+        log_id,
+        body,
+        append_reference,
+        file_name,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if log_document_id is not None:
+            _path_params['logDocumentId'] = log_document_id
+        if log_id is not None:
+            _path_params['logId'] = log_id
+        # process the query parameters
+        if append_reference is not None:
+            
+            _query_params.append(('appendReference', append_reference))
+            
+        if file_name is not None:
+            
+            _query_params.append(('fileName', file_name))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+        if body is not None:
+            # convert to byte array if the input is a file name (str)
+            if isinstance(body, str):
+                with open(body, "rb") as _fp:
+                    _body_params = _fp.read()
+            elif isinstance(body, tuple):
+                # drop the filename from the tuple
+                _body_params = body[1]
+            else:
+                _body_params = body
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'application/octet-stream'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'belyAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='PUT',
+            resource_path='/api/Logbook/UploadAttachment/{logDocumentId}/{logId}',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+

{bely_api-2026.3.dev3 → bely_api-2026.3.dev4}/belyApi/models/__init__.py

@@ -42,6 +42,7 @@ from belyApi.models.log import Log
 from belyApi.models.log_document_options import LogDocumentOptions
 from belyApi.models.log_document_section import LogDocumentSection
 from belyApi.models.log_entry import LogEntry
+from belyApi.models.log_entry_attachment import LogEntryAttachment
 from belyApi.models.log_reaction import LogReaction
 from belyApi.models.logbook_search_results import LogbookSearchResults
 from belyApi.models.notification_configuration import NotificationConfiguration

{bely_api-2026.3.dev3 → bely_api-2026.3.dev4}/belyApi/models/api_exception_message_exception_cause_stack_trace_inner.py

@@ -33,9 +33,9 @@ class ApiExceptionMessageExceptionCauseStackTraceInner(BaseModel):
     method_name: Optional[StrictStr] = Field(default=None, alias="methodName")
     file_name: Optional[StrictStr] = Field(default=None, alias="fileName")
     line_number: Optional[StrictInt] = Field(default=None, alias="lineNumber")
-    native_method: Optional[StrictBool] = Field(default=None, alias="nativeMethod")
     class_name: Optional[StrictStr] = Field(default=None, alias="className")
-    __properties: ClassVar[List[str]] = ["classLoaderName", "moduleName", "moduleVersion", "methodName", "fileName", "lineNumber", "nativeMethod", "className"]
+    native_method: Optional[StrictBool] = Field(default=None, alias="nativeMethod")
+    __properties: ClassVar[List[str]] = ["classLoaderName", "moduleName", "moduleVersion", "methodName", "fileName", "lineNumber", "className", "nativeMethod"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -94,8 +94,8 @@ class ApiExceptionMessageExceptionCauseStackTraceInner(BaseModel):
             "methodName": obj.get("methodName"),
             "fileName": obj.get("fileName"),
             "lineNumber": obj.get("lineNumber"),
-            "nativeMethod": obj.get("nativeMethod"),
-            "className": obj.get("className")
+            "className": obj.get("className"),
+            "nativeMethod": obj.get("nativeMethod")
         })
         return _obj
 

{bely_api-2026.3.dev3 → bely_api-2026.3.dev4}/belyApi/models/entity_info.py

@@ -33,12 +33,12 @@ class EntityInfo(BaseModel):
     created_on_date_time: datetime = Field(alias="createdOnDateTime")
     last_modified_on_date_time: datetime = Field(alias="lastModifiedOnDateTime")
     obsoleted_on_date_time: Optional[datetime] = Field(default=None, alias="obsoletedOnDateTime")
+    owner_username: Optional[StrictStr] = Field(default=None, alias="ownerUsername")
+    owner_user_group_name: Optional[StrictStr] = Field(default=None, alias="ownerUserGroupName")
     created_by_username: Optional[StrictStr] = Field(default=None, alias="createdByUsername")
     obsoleted_by_username: Optional[StrictStr] = Field(default=None, alias="obsoletedByUsername")
     last_modified_by_username: Optional[StrictStr] = Field(default=None, alias="lastModifiedByUsername")
-    owner_username: Optional[StrictStr] = Field(default=None, alias="ownerUsername")
-    owner_user_group_name: Optional[StrictStr] = Field(default=None, alias="ownerUserGroupName")
-    __properties: ClassVar[List[str]] = ["id", "isGroupWriteable", "createdOnDateTime", "lastModifiedOnDateTime", "obsoletedOnDateTime", "createdByUsername", "obsoletedByUsername", "lastModifiedByUsername", "ownerUsername", "ownerUserGroupName"]
+    __properties: ClassVar[List[str]] = ["id", "isGroupWriteable", "createdOnDateTime", "lastModifiedOnDateTime", "obsoletedOnDateTime", "ownerUsername", "ownerUserGroupName", "createdByUsername", "obsoletedByUsername", "lastModifiedByUsername"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -96,11 +96,11 @@ class EntityInfo(BaseModel):
             "createdOnDateTime": obj.get("createdOnDateTime"),
             "lastModifiedOnDateTime": obj.get("lastModifiedOnDateTime"),
             "obsoletedOnDateTime": obj.get("obsoletedOnDateTime"),
+            "ownerUsername": obj.get("ownerUsername"),
+            "ownerUserGroupName": obj.get("ownerUserGroupName"),
             "createdByUsername": obj.get("createdByUsername"),
             "obsoletedByUsername": obj.get("obsoletedByUsername"),
-            "lastModifiedByUsername": obj.get("lastModifiedByUsername"),
-            "ownerUsername": obj.get("ownerUsername"),
-            "ownerUserGroupName": obj.get("ownerUserGroupName")
+            "lastModifiedByUsername": obj.get("lastModifiedByUsername")
         })
         return _obj
 

{bely_api-2026.3.dev3 → bely_api-2026.3.dev4}/belyApi/models/item_element.py

@@ -43,12 +43,12 @@ class ItemElement(BaseModel):
     represents_item_element_list: Optional[List[ItemElement]] = Field(default=None, alias="representsItemElementList")
     represents_item_element: Optional[ItemElement] = Field(default=None, alias="representsItemElement")
     item_element_history_list: Optional[List[ItemElementHistory]] = Field(default=None, alias="itemElementHistoryList")
-    relevant_item_element_name: Optional[StrictStr] = Field(default=None, alias="relevantItemElementName")
+    parent_item_id: Optional[StrictInt] = Field(default=None, alias="parentItemId")
     contained_item1_id: Optional[StrictInt] = Field(default=None, alias="containedItem1Id")
+    relevant_item_element_name: Optional[StrictStr] = Field(default=None, alias="relevantItemElementName")
     contained_item2_id: Optional[StrictInt] = Field(default=None, alias="containedItem2Id")
-    parent_item_id: Optional[StrictInt] = Field(default=None, alias="parentItemId")
     relevant_item_element_sort_order: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, alias="relevantItemElementSortOrder")
-    __properties: ClassVar[List[str]] = ["id", "name", "isRequired", "isHoused", "description", "sortOrder", "listList", "propertyValueList", "logList", "derivedFromItemElementList", "derivedFromItemElement", "representsItemElementList", "representsItemElement", "itemElementHistoryList", "relevantItemElementName", "containedItem1Id", "containedItem2Id", "parentItemId", "relevantItemElementSortOrder"]
+    __properties: ClassVar[List[str]] = ["id", "name", "isRequired", "isHoused", "description", "sortOrder", "listList", "propertyValueList", "logList", "derivedFromItemElementList", "derivedFromItemElement", "representsItemElementList", "representsItemElement", "itemElementHistoryList", "parentItemId", "containedItem1Id", "relevantItemElementName", "containedItem2Id", "relevantItemElementSortOrder"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -163,10 +163,10 @@ class ItemElement(BaseModel):
             "representsItemElementList": [ItemElement.from_dict(_item) for _item in obj["representsItemElementList"]] if obj.get("representsItemElementList") is not None else None,
             "representsItemElement": ItemElement.from_dict(obj["representsItemElement"]) if obj.get("representsItemElement") is not None else None,
             "itemElementHistoryList": [ItemElementHistory.from_dict(_item) for _item in obj["itemElementHistoryList"]] if obj.get("itemElementHistoryList") is not None else None,
-            "relevantItemElementName": obj.get("relevantItemElementName"),
+            "parentItemId": obj.get("parentItemId"),
             "containedItem1Id": obj.get("containedItem1Id"),
+            "relevantItemElementName": obj.get("relevantItemElementName"),
             "containedItem2Id": obj.get("containedItem2Id"),
-            "parentItemId": obj.get("parentItemId"),
             "relevantItemElementSortOrder": obj.get("relevantItemElementSortOrder")
         })
         return _obj

{bely_api-2026.3.dev3 → bely_api-2026.3.dev4}/belyApi/models/item_element_relationship.py

@@ -50,14 +50,14 @@ class ItemElementRelationship(BaseModel):
     import_first_item_connector_name: Optional[StrictStr] = Field(default=None, alias="importFirstItemConnectorName")
     import_second_item_connector_name: Optional[StrictStr] = Field(default=None, alias="importSecondItemConnectorName")
     import_primary_cable_connection: Optional[StrictBool] = Field(default=None, alias="importPrimaryCableConnection")
+    primary_cable_connection: Optional[StrictBool] = Field(default=None, alias="primaryCableConnection")
     first_item_connector_name: Optional[StrictStr] = Field(default=None, alias="firstItemConnectorName")
     second_item: Optional[Item] = Field(default=None, alias="secondItem")
     second_item_connector_name: Optional[StrictStr] = Field(default=None, alias="secondItemConnectorName")
-    primary_cable_connection: Optional[StrictBool] = Field(default=None, alias="primaryCableConnection")
     first_item: Optional[Item] = Field(default=None, alias="firstItem")
     cable_end_primary_indicator: Optional[StrictStr] = Field(default=None, alias="cableEndPrimaryIndicator")
     cable_end_primary_sort_value: Optional[StrictStr] = Field(default=None, alias="cableEndPrimarySortValue")
-    __properties: ClassVar[List[str]] = ["id", "relationshipDetails", "label", "description", "propertyValueList", "itemElementRelationshipHistoryList", "firstItemElement", "firstItemConnector", "firstSortOrder", "secondItemElement", "secondItemConnector", "secondSortOrder", "relationshipForParent", "relationshipType", "linkItemElement", "resourceType", "importFirstItem", "importSecondItem", "importFirstItemConnectorName", "importSecondItemConnectorName", "importPrimaryCableConnection", "firstItemConnectorName", "secondItem", "secondItemConnectorName", "primaryCableConnection", "firstItem", "cableEndPrimaryIndicator", "cableEndPrimarySortValue"]
+    __properties: ClassVar[List[str]] = ["id", "relationshipDetails", "label", "description", "propertyValueList", "itemElementRelationshipHistoryList", "firstItemElement", "firstItemConnector", "firstSortOrder", "secondItemElement", "secondItemConnector", "secondSortOrder", "relationshipForParent", "relationshipType", "linkItemElement", "resourceType", "importFirstItem", "importSecondItem", "importFirstItemConnectorName", "importSecondItemConnectorName", "importPrimaryCableConnection", "primaryCableConnection", "firstItemConnectorName", "secondItem", "secondItemConnectorName", "firstItem", "cableEndPrimaryIndicator", "cableEndPrimarySortValue"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -181,10 +181,10 @@ class ItemElementRelationship(BaseModel):
             "importFirstItemConnectorName": obj.get("importFirstItemConnectorName"),
             "importSecondItemConnectorName": obj.get("importSecondItemConnectorName"),
             "importPrimaryCableConnection": obj.get("importPrimaryCableConnection"),
+            "primaryCableConnection": obj.get("primaryCableConnection"),
             "firstItemConnectorName": obj.get("firstItemConnectorName"),
             "secondItem": Item.from_dict(obj["secondItem"]) if obj.get("secondItem") is not None else None,
             "secondItemConnectorName": obj.get("secondItemConnectorName"),
-            "primaryCableConnection": obj.get("primaryCableConnection"),
             "firstItem": Item.from_dict(obj["firstItem"]) if obj.get("firstItem") is not None else None,
             "cableEndPrimaryIndicator": obj.get("cableEndPrimaryIndicator"),
             "cableEndPrimarySortValue": obj.get("cableEndPrimarySortValue")

{bely_api-2026.3.dev3 → bely_api-2026.3.dev4}/belyApi/models/log.py

@@ -41,9 +41,9 @@ class Log(BaseModel):
     parent_log: Optional[Log] = Field(default=None, alias="parentLog")
     child_log_list: Optional[List[Log]] = Field(default=None, alias="childLogList")
     log_reaction_list: Optional[List[LogReaction]] = Field(default=None, alias="logReactionList")
-    entered_by_username: Optional[StrictStr] = Field(default=None, alias="enteredByUsername")
     last_modified_by_username: Optional[StrictStr] = Field(default=None, alias="lastModifiedByUsername")
-    __properties: ClassVar[List[str]] = ["id", "text", "enteredOnDateTime", "lastModifiedOnDateTime", "effectiveFromDateTime", "effectiveToDateTime", "lastModifiedByUser", "parentLog", "childLogList", "logReactionList", "enteredByUsername", "lastModifiedByUsername"]
+    entered_by_username: Optional[StrictStr] = Field(default=None, alias="enteredByUsername")
+    __properties: ClassVar[List[str]] = ["id", "text", "enteredOnDateTime", "lastModifiedOnDateTime", "effectiveFromDateTime", "effectiveToDateTime", "lastModifiedByUser", "parentLog", "childLogList", "logReactionList", "lastModifiedByUsername", "enteredByUsername"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -126,8 +126,8 @@ class Log(BaseModel):
             "parentLog": Log.from_dict(obj["parentLog"]) if obj.get("parentLog") is not None else None,
             "childLogList": [Log.from_dict(_item) for _item in obj["childLogList"]] if obj.get("childLogList") is not None else None,
             "logReactionList": [LogReaction.from_dict(_item) for _item in obj["logReactionList"]] if obj.get("logReactionList") is not None else None,
-            "enteredByUsername": obj.get("enteredByUsername"),
-            "lastModifiedByUsername": obj.get("lastModifiedByUsername")
+            "lastModifiedByUsername": obj.get("lastModifiedByUsername"),
+            "enteredByUsername": obj.get("enteredByUsername")
         })
         return _obj
 

bely_api-2026.3.dev4/belyApi/models/log_entry_attachment.py

@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+    BELY API
+
+    The API that provides access to BELY data.
+
+    The version of the OpenAPI document: 2024.5
+    Contact: djarosz@anl.gov
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class LogEntryAttachment(BaseModel):
+    """
+    LogEntryAttachment
+    """ # noqa: E501
+    markdown_reference: Optional[StrictStr] = Field(default=None, alias="markdownReference")
+    download_path: Optional[StrictStr] = Field(default=None, alias="downloadPath")
+    original_filename: Optional[StrictStr] = Field(default=None, alias="originalFilename")
+    stored_filename: Optional[StrictStr] = Field(default=None, alias="storedFilename")
+    __properties: ClassVar[List[str]] = ["markdownReference", "downloadPath", "originalFilename", "storedFilename"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of LogEntryAttachment from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of LogEntryAttachment from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "markdownReference": obj.get("markdownReference"),
+            "downloadPath": obj.get("downloadPath"),
+            "originalFilename": obj.get("originalFilename"),
+            "storedFilename": obj.get("storedFilename")
+        })
+        return _obj
+
+

{bely_api-2026.3.dev3 → bely_api-2026.3.dev4}/belyApi/models/user_info.py

@@ -39,9 +39,9 @@ class UserInfo(BaseModel):
     email: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=64)]] = None
     description: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=256)]] = None
     notification_configuration_collection: Optional[List[NotificationConfiguration]] = Field(default=None, alias="notificationConfigurationCollection")
-    user_group_list: Optional[List[UserGroup]] = Field(default=None, alias="userGroupList")
     user_role_list: Optional[List[UserRole]] = Field(default=None, alias="userRoleList")
-    __properties: ClassVar[List[str]] = ["id", "username", "firstName", "lastName", "middleName", "email", "description", "notificationConfigurationCollection", "userGroupList", "userRoleList"]
+    user_group_list: Optional[List[UserGroup]] = Field(default=None, alias="userGroupList")
+    __properties: ClassVar[List[str]] = ["id", "username", "firstName", "lastName", "middleName", "email", "description", "notificationConfigurationCollection", "userRoleList", "userGroupList"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -89,13 +89,6 @@ class UserInfo(BaseModel):
                 if _item_notification_configuration_collection:
                     _items.append(_item_notification_configuration_collection.to_dict())
             _dict['notificationConfigurationCollection'] = _items
-        # override the default output from pydantic by calling `to_dict()` of each item in user_group_list (list)
-        _items = []
-        if self.user_group_list:
-            for _item_user_group_list in self.user_group_list:
-                if _item_user_group_list:
-                    _items.append(_item_user_group_list.to_dict())
-            _dict['userGroupList'] = _items
         # override the default output from pydantic by calling `to_dict()` of each item in user_role_list (list)
         _items = []
         if self.user_role_list:
@@ -103,6 +96,13 @@ class UserInfo(BaseModel):
                 if _item_user_role_list:
                     _items.append(_item_user_role_list.to_dict())
             _dict['userRoleList'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in user_group_list (list)
+        _items = []
+        if self.user_group_list:
+            for _item_user_group_list in self.user_group_list:
+                if _item_user_group_list:
+                    _items.append(_item_user_group_list.to_dict())
+            _dict['userGroupList'] = _items
         return _dict
 
     @classmethod
@@ -123,8 +123,8 @@ class UserInfo(BaseModel):
             "email": obj.get("email"),
             "description": obj.get("description"),
             "notificationConfigurationCollection": [NotificationConfiguration.from_dict(_item) for _item in obj["notificationConfigurationCollection"]] if obj.get("notificationConfigurationCollection") is not None else None,
-            "userGroupList": [UserGroup.from_dict(_item) for _item in obj["userGroupList"]] if obj.get("userGroupList") is not None else None,
-            "userRoleList": [UserRole.from_dict(_item) for _item in obj["userRoleList"]] if obj.get("userRoleList") is not None else None
+            "userRoleList": [UserRole.from_dict(_item) for _item in obj["userRoleList"]] if obj.get("userRoleList") is not None else None,
+            "userGroupList": [UserGroup.from_dict(_item) for _item in obj["userGroupList"]] if obj.get("userGroupList") is not None else None
         })
         return _obj
 

{bely_api-2026.3.dev3 → bely_api-2026.3.dev4}/bely_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bely-api
-Version: 2026.3.dev3
+Version: 2026.3.dev4
 Summary: Python client API library used to communicate with BELY API.
 Home-page: https://git.aps.anl.gov/controls/hla/bely
 Maintainer: Dariusz Jarosz

{bely_api-2026.3.dev3 → bely_api-2026.3.dev4}/bely_api.egg-info/SOURCES.txt

@@ -46,6 +46,7 @@ belyApi/models/log.py
 belyApi/models/log_document_options.py
 belyApi/models/log_document_section.py
 belyApi/models/log_entry.py
+belyApi/models/log_entry_attachment.py
 belyApi/models/log_reaction.py
 belyApi/models/logbook_search_results.py
 belyApi/models/notification_configuration.py

{bely_api-2026.3.dev3 → bely_api-2026.3.dev4}/setup.py

@@ -8,7 +8,7 @@ See LICENSE file.
 from setuptools import setup
 
 setup(name='bely_api',
-      version='2026.3.dev3',
+      version='2026.3.dev4',
       packages=["belyApi",
                 "belyApi.api",
                 "belyApi.models"],