mindconnect.models package

Submodules

mindconnect.models.badrequest module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class Badrequest(id=None, message=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'id': 'id', 'message': 'message'}
attribute_types = {'id': 'str', 'message': 'str'}
id

Gets the id of this Badrequest.

Returns:The id of this Badrequest.
Return type:str
message

Gets the message of this Badrequest.

Returns:The message of this Badrequest.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.conflict module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class Conflict(id=None, message=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'id': 'id', 'message': 'message'}
attribute_types = {'id': 'str', 'message': 'str'}
id

Gets the id of this Conflict.

Returns:The id of this Conflict.
Return type:str
message

Gets the message of this Conflict.

Returns:The message of this Conflict.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.data_point_mappings_get_request module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class DataPointMappingsGetRequest(filter=None, size=None, page=None, sort=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'filter': 'filter', 'page': 'page', 'size': 'size', 'sort': 'sort'}
attribute_types = {'filter': 'str', 'page': 'int', 'size': 'int', 'sort': 'str'}
filter

Gets the filter of this DataPointMappingsGetRequest.

Returns:The filter of this DataPointMappingsGetRequest.
Return type:str
page

Gets the page of this DataPointMappingsGetRequest.

Returns:The page of this DataPointMappingsGetRequest.
Return type:int
size

Gets the size of this DataPointMappingsGetRequest.

Returns:The size of this DataPointMappingsGetRequest.
Return type:int
sort

Gets the sort of this DataPointMappingsGetRequest.

Returns:The sort of this DataPointMappingsGetRequest.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.data_point_mappings_id_delete_request module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class DataPointMappingsIdDeleteRequest(id=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'id': 'id'}
attribute_types = {'id': 'str'}
id

Gets the id of this DataPointMappingsIdDeleteRequest.

Returns:The id of this DataPointMappingsIdDeleteRequest.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.data_point_mappings_id_get_request module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class DataPointMappingsIdGetRequest(id=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'id': 'id'}
attribute_types = {'id': 'str'}
id

Gets the id of this DataPointMappingsIdGetRequest.

Returns:The id of this DataPointMappingsIdGetRequest.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.data_point_mappings_post_request module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class DataPointMappingsPostRequest(mapping=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'mapping': 'mapping'}
attribute_types = {'mapping': 'Mapping'}
mapping

Gets the mapping of this DataPointMappingsPostRequest.

Returns:The mapping of this DataPointMappingsPostRequest.
Return type:Mapping
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.diagnostic_activation module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class DiagnosticActivation(id=None, agent_id=None, status=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
agent_id

Gets the agent_id of this DiagnosticActivation. Unique identifier of the agent

Returns:The agent_id of this DiagnosticActivation.
Return type:str
attribute_map = {'agent_id': 'agentId', 'id': 'id', 'status': 'status'}
attribute_types = {'agent_id': 'str', 'id': 'str', 'status': 'str'}
id

Gets the id of this DiagnosticActivation. Unique identifier of diagnostic activation resource

Returns:The id of this DiagnosticActivation.
Return type:str
status

Gets the status of this DiagnosticActivation. Status of the activation

Returns:The status of this DiagnosticActivation.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.diagnostic_activation_status module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class DiagnosticActivationStatus(status=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'status': 'status'}
attribute_types = {'status': 'str'}
status

Gets the status of this DiagnosticActivationStatus. Status of the activation

Returns:The status of this DiagnosticActivationStatus.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.diagnostic_activations_get_request module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class DiagnosticActivationsGetRequest(size=None, page=None, sort=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'page': 'page', 'size': 'size', 'sort': 'sort'}
attribute_types = {'page': 'int', 'size': 'int', 'sort': 'str'}
page

Gets the page of this DiagnosticActivationsGetRequest.

Returns:The page of this DiagnosticActivationsGetRequest.
Return type:int
size

Gets the size of this DiagnosticActivationsGetRequest.

Returns:The size of this DiagnosticActivationsGetRequest.
Return type:int
sort

Gets the sort of this DiagnosticActivationsGetRequest.

Returns:The sort of this DiagnosticActivationsGetRequest.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.diagnostic_activations_id_delete_request module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class DiagnosticActivationsIdDeleteRequest(id=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'id': 'id'}
attribute_types = {'id': 'str'}
id

Gets the id of this DiagnosticActivationsIdDeleteRequest.

Returns:The id of this DiagnosticActivationsIdDeleteRequest.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.diagnostic_activations_id_get_request module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class DiagnosticActivationsIdGetRequest(id=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'id': 'id'}
attribute_types = {'id': 'str'}
id

Gets the id of this DiagnosticActivationsIdGetRequest.

Returns:The id of this DiagnosticActivationsIdGetRequest.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.diagnostic_activations_id_messages_get_request module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class DiagnosticActivationsIdMessagesGetRequest(filter=None, size=None, id=None, page=None, sort=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'filter': 'filter', 'id': 'id', 'page': 'page', 'size': 'size', 'sort': 'sort'}
attribute_types = {'filter': 'str', 'id': 'str', 'page': 'int', 'size': 'int', 'sort': 'str'}
filter

Gets the filter of this DiagnosticActivationsIdMessagesGetRequest.

Returns:The filter of this DiagnosticActivationsIdMessagesGetRequest.
Return type:str
id

Gets the id of this DiagnosticActivationsIdMessagesGetRequest.

Returns:The id of this DiagnosticActivationsIdMessagesGetRequest.
Return type:str
page

Gets the page of this DiagnosticActivationsIdMessagesGetRequest.

Returns:The page of this DiagnosticActivationsIdMessagesGetRequest.
Return type:int
size

Gets the size of this DiagnosticActivationsIdMessagesGetRequest.

Returns:The size of this DiagnosticActivationsIdMessagesGetRequest.
Return type:int
sort

Gets the sort of this DiagnosticActivationsIdMessagesGetRequest.

Returns:The sort of this DiagnosticActivationsIdMessagesGetRequest.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.diagnostic_activations_id_put_request module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class DiagnosticActivationsIdPutRequest(diagnostic_activation_status=None, id=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'diagnostic_activation_status': 'diagnosticActivationStatus', 'id': 'id'}
attribute_types = {'diagnostic_activation_status': 'DiagnosticActivationStatus', 'id': 'str'}
diagnostic_activation_status

Gets the diagnostic_activation_status of this DiagnosticActivationsIdPutRequest.

Returns:The diagnostic_activation_status of this DiagnosticActivationsIdPutRequest.
Return type:DiagnosticActivationStatus
id

Gets the id of this DiagnosticActivationsIdPutRequest.

Returns:The id of this DiagnosticActivationsIdPutRequest.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.diagnostic_activations_post_request module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class DiagnosticActivationsPostRequest(diagnostic_activation=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'diagnostic_activation': 'diagnosticActivation'}
attribute_types = {'diagnostic_activation': 'DiagnosticActivation'}
diagnostic_activation

Gets the diagnostic_activation of this DiagnosticActivationsPostRequest.

Returns:The diagnostic_activation of this DiagnosticActivationsPostRequest.
Return type:DiagnosticActivation
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.diagnostic_information module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class DiagnosticInformation(agent_id=None, correlation_id=None, severity=None, message=None, source=None, state=None, timestamp=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
agent_id

Gets the agent_id of this DiagnosticInformation.

Returns:The agent_id of this DiagnosticInformation.
Return type:str
attribute_map = {'agent_id': 'agentId', 'correlation_id': 'correlationId', 'message': 'message', 'severity': 'severity', 'source': 'source', 'state': 'state', 'timestamp': 'timestamp'}
attribute_types = {'agent_id': 'str', 'correlation_id': 'str', 'message': 'str', 'severity': 'str', 'source': 'str', 'state': 'str', 'timestamp': 'datetime'}
correlation_id

Gets the correlation_id of this DiagnosticInformation.

Returns:The correlation_id of this DiagnosticInformation.
Return type:str
message

Gets the message of this DiagnosticInformation.

Returns:The message of this DiagnosticInformation.
Return type:str
severity

Gets the severity of this DiagnosticInformation.

Returns:The severity of this DiagnosticInformation.
Return type:str
source

Gets the source of this DiagnosticInformation. Source of diagnostic information.

Returns:The source of this DiagnosticInformation.
Return type:str
state

Gets the state of this DiagnosticInformation. State of diagnostic information.

Returns:The state of this DiagnosticInformation.
Return type:str
timestamp

Gets the timestamp of this DiagnosticInformation. Diagnostic information creation date.

Returns:The timestamp of this DiagnosticInformation.
Return type:datetime
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.diagnostic_information_message module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class DiagnosticInformationMessage(correlation_id=None, severity=None, message=None, source=None, state=None, timestamp=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'correlation_id': 'correlationId', 'message': 'message', 'severity': 'severity', 'source': 'source', 'state': 'state', 'timestamp': 'timestamp'}
attribute_types = {'correlation_id': 'str', 'message': 'str', 'severity': 'str', 'source': 'str', 'state': 'str', 'timestamp': 'datetime'}
correlation_id

Gets the correlation_id of this DiagnosticInformationMessage.

Returns:The correlation_id of this DiagnosticInformationMessage.
Return type:str
message

Gets the message of this DiagnosticInformationMessage.

Returns:The message of this DiagnosticInformationMessage.
Return type:str
severity

Gets the severity of this DiagnosticInformationMessage.

Returns:The severity of this DiagnosticInformationMessage.
Return type:str
source

Gets the source of this DiagnosticInformationMessage. Source of diagnostic information.

Returns:The source of this DiagnosticInformationMessage.
Return type:str
state

Gets the state of this DiagnosticInformationMessage. State of diagnostic information.

Returns:The state of this DiagnosticInformationMessage.
Return type:str
timestamp

Gets the timestamp of this DiagnosticInformationMessage. Diagnostic information creation date.

Returns:The timestamp of this DiagnosticInformationMessage.
Return type:datetime
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.error module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class Error(id=None, message=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'id': 'id', 'message': 'message'}
attribute_types = {'id': 'str', 'message': 'str'}
id

Gets the id of this Error.

Returns:The id of this Error.
Return type:str
message

Gets the message of this Error.

Returns:The message of this Error.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.forbidden module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class Forbidden(id=None, message=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'id': 'id', 'message': 'message'}
attribute_types = {'id': 'str', 'message': 'str'}
id

Gets the id of this Forbidden.

Returns:The id of this Forbidden.
Return type:str
message

Gets the message of this Forbidden.

Returns:The message of this Forbidden.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.mapping module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class Mapping(id=None, agent_id=None, data_point_id=None, data_point_unit=None, data_point_type=None, entity_id=None, property_set_name=None, property_name=None, property_unit=None, property_type=None, quality_enabled=None, keep_mapping=False)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
agent_id

Gets the agent_id of this Mapping. Unique identifier of the agent

Returns:The agent_id of this Mapping.
Return type:str
attribute_map = {'agent_id': 'agentId', 'data_point_id': 'dataPointId', 'data_point_type': 'dataPointType', 'data_point_unit': 'dataPointUnit', 'entity_id': 'entityId', 'id': 'id', 'keep_mapping': 'keepMapping', 'property_name': 'propertyName', 'property_set_name': 'propertySetName', 'property_type': 'propertyType', 'property_unit': 'propertyUnit', 'quality_enabled': 'qualityEnabled'}
attribute_types = {'agent_id': 'str', 'data_point_id': 'str', 'data_point_type': 'str', 'data_point_unit': 'str', 'entity_id': 'str', 'id': 'str', 'keep_mapping': 'bool', 'property_name': 'str', 'property_set_name': 'str', 'property_type': 'str', 'property_unit': 'str', 'quality_enabled': 'bool'}
data_point_id

Gets the data_point_id of this Mapping. Unique identifier of the data point

Returns:The data_point_id of this Mapping.
Return type:str
data_point_type

Gets the data_point_type of this Mapping. Type of the data point

Returns:The data_point_type of this Mapping.
Return type:str
data_point_unit

Gets the data_point_unit of this Mapping. Unit of the data point

Returns:The data_point_unit of this Mapping.
Return type:str
entity_id

Gets the entity_id of this Mapping. Unique identifier of the entity

Returns:The entity_id of this Mapping.
Return type:str
id

Gets the id of this Mapping. Unique identifier of the mapping resource

Returns:The id of this Mapping.
Return type:str
keep_mapping

Gets the keep_mapping of this Mapping. Identifies auto deleting mapping or keeping mapping.

Returns:The keep_mapping of this Mapping.
Return type:bool
property_name

Gets the property_name of this Mapping.

Returns:The property_name of this Mapping.
Return type:str
property_set_name

Gets the property_set_name of this Mapping.

Returns:The property_set_name of this Mapping.
Return type:str
property_type

Gets the property_type of this Mapping.

Returns:The property_type of this Mapping.
Return type:str
property_unit

Gets the property_unit of this Mapping.

Returns:The property_unit of this Mapping.
Return type:str
quality_enabled

Gets the quality_enabled of this Mapping.

Returns:The quality_enabled of this Mapping.
Return type:bool
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.notfound module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class Notfound(id=None, message=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'id': 'id', 'message': 'message'}
attribute_types = {'id': 'str', 'message': 'str'}
id

Gets the id of this Notfound.

Returns:The id of this Notfound.
Return type:str
message

Gets the message of this Notfound.

Returns:The message of this Notfound.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.order module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class Order(direction=None, _property=None, ignore_case=None, null_handling=None, descending=None, ascending=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
_property

Gets the _property of this Order. The property to order for.

Returns:The _property of this Order.
Return type:str
ascending

Gets the ascending of this Order. Whether sorting for this property shall be ascending.

Returns:The ascending of this Order.
Return type:bool
attribute_map = {'_property': 'property', 'ascending': 'ascending', 'descending': 'descending', 'direction': 'direction', 'ignore_case': 'ignoreCase', 'null_handling': 'nullHandling'}
attribute_types = {'_property': 'str', 'ascending': 'bool', 'descending': 'bool', 'direction': 'str', 'ignore_case': 'bool', 'null_handling': 'str'}
descending

Gets the descending of this Order. Whether sorting for this property shall be descending.

Returns:The descending of this Order.
Return type:bool
direction

Gets the direction of this Order. The order the property shall be sorted for.

Returns:The direction of this Order.
Return type:str
ignore_case

Gets the ignore_case of this Order. Whether or not the sort will be case sensitive.

Returns:The ignore_case of this Order.
Return type:bool
null_handling

Gets the null_handling of this Order.

Returns:The null_handling of this Order.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.paged_diagnostic_activation module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class PagedDiagnosticActivation(content=None, last=None, total_pages=None, total_elements=None, number_of_elements=None, first=None, sort=None, size=None, number=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'content': 'content', 'first': 'first', 'last': 'last', 'number': 'number', 'number_of_elements': 'numberOfElements', 'size': 'size', 'sort': 'sort', 'total_elements': 'totalElements', 'total_pages': 'totalPages'}
attribute_types = {'content': 'list[DiagnosticActivation]', 'first': 'bool', 'last': 'bool', 'number': 'int', 'number_of_elements': 'int', 'size': 'int', 'sort': 'list[Order]', 'total_elements': 'int', 'total_pages': 'int'}
content

Gets the content of this PagedDiagnosticActivation.

Returns:The content of this PagedDiagnosticActivation.
Return type:list[DiagnosticActivation]
first

Gets the first of this PagedDiagnosticActivation. Whether the current item is the first one.

Returns:The first of this PagedDiagnosticActivation.
Return type:bool
last

Gets the last of this PagedDiagnosticActivation. Whether the current item is the last one.

Returns:The last of this PagedDiagnosticActivation.
Return type:bool
number

Gets the number of this PagedDiagnosticActivation. The number of the current item.

Returns:The number of this PagedDiagnosticActivation.
Return type:int
number_of_elements

Gets the number_of_elements of this PagedDiagnosticActivation. The number of elements currently on this page.

Returns:The number_of_elements of this PagedDiagnosticActivation.
Return type:int
size

Gets the size of this PagedDiagnosticActivation. The size of the page.

Returns:The size of this PagedDiagnosticActivation.
Return type:int
sort

Gets the sort of this PagedDiagnosticActivation. The sorting parameters for the page.

Returns:The sort of this PagedDiagnosticActivation.
Return type:list[Order]
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

total_elements

Gets the total_elements of this PagedDiagnosticActivation. The total amount of elements.

Returns:The total_elements of this PagedDiagnosticActivation.
Return type:int
total_pages

Gets the total_pages of this PagedDiagnosticActivation. The number of total pages.

Returns:The total_pages of this PagedDiagnosticActivation.
Return type:int

mindconnect.models.paged_diagnostic_information module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class PagedDiagnosticInformation(content=None, last=None, total_pages=None, total_elements=None, number_of_elements=None, first=None, sort=None, size=None, number=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'content': 'content', 'first': 'first', 'last': 'last', 'number': 'number', 'number_of_elements': 'numberOfElements', 'size': 'size', 'sort': 'sort', 'total_elements': 'totalElements', 'total_pages': 'totalPages'}
attribute_types = {'content': 'list[DiagnosticInformation]', 'first': 'bool', 'last': 'bool', 'number': 'int', 'number_of_elements': 'int', 'size': 'int', 'sort': 'list[Order]', 'total_elements': 'int', 'total_pages': 'int'}
content

Gets the content of this PagedDiagnosticInformation.

Returns:The content of this PagedDiagnosticInformation.
Return type:list[DiagnosticInformation]
first

Gets the first of this PagedDiagnosticInformation. Whether the current item is the first one.

Returns:The first of this PagedDiagnosticInformation.
Return type:bool
last

Gets the last of this PagedDiagnosticInformation. Whether the current item is the last one.

Returns:The last of this PagedDiagnosticInformation.
Return type:bool
number

Gets the number of this PagedDiagnosticInformation. The number of the current item.

Returns:The number of this PagedDiagnosticInformation.
Return type:int
number_of_elements

Gets the number_of_elements of this PagedDiagnosticInformation. The number of elements currently on this page.

Returns:The number_of_elements of this PagedDiagnosticInformation.
Return type:int
size

Gets the size of this PagedDiagnosticInformation. The size of the page.

Returns:The size of this PagedDiagnosticInformation.
Return type:int
sort

Gets the sort of this PagedDiagnosticInformation. The sorting parameters for the page.

Returns:The sort of this PagedDiagnosticInformation.
Return type:list[Order]
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

total_elements

Gets the total_elements of this PagedDiagnosticInformation. The total amount of elements.

Returns:The total_elements of this PagedDiagnosticInformation.
Return type:int
total_pages

Gets the total_pages of this PagedDiagnosticInformation. The number of total pages.

Returns:The total_pages of this PagedDiagnosticInformation.
Return type:int

mindconnect.models.paged_diagnostic_information_messages module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class PagedDiagnosticInformationMessages(content=None, last=None, total_pages=None, total_elements=None, number_of_elements=None, first=None, sort=None, size=None, number=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'content': 'content', 'first': 'first', 'last': 'last', 'number': 'number', 'number_of_elements': 'numberOfElements', 'size': 'size', 'sort': 'sort', 'total_elements': 'totalElements', 'total_pages': 'totalPages'}
attribute_types = {'content': 'list[DiagnosticInformationMessage]', 'first': 'bool', 'last': 'bool', 'number': 'int', 'number_of_elements': 'int', 'size': 'int', 'sort': 'list[Order]', 'total_elements': 'int', 'total_pages': 'int'}
content

Gets the content of this PagedDiagnosticInformationMessages.

Returns:The content of this PagedDiagnosticInformationMessages.
Return type:list[DiagnosticInformationMessage]
first

Gets the first of this PagedDiagnosticInformationMessages. Whether the current item is the first one.

Returns:The first of this PagedDiagnosticInformationMessages.
Return type:bool
last

Gets the last of this PagedDiagnosticInformationMessages. Whether the current item is the last one.

Returns:The last of this PagedDiagnosticInformationMessages.
Return type:bool
number

Gets the number of this PagedDiagnosticInformationMessages. The number of the current item.

Returns:The number of this PagedDiagnosticInformationMessages.
Return type:int
number_of_elements

Gets the number_of_elements of this PagedDiagnosticInformationMessages. The number of elements currently on this page.

Returns:The number_of_elements of this PagedDiagnosticInformationMessages.
Return type:int
size

Gets the size of this PagedDiagnosticInformationMessages. The size of the page.

Returns:The size of this PagedDiagnosticInformationMessages.
Return type:int
sort

Gets the sort of this PagedDiagnosticInformationMessages. The sorting parameters for the page.

Returns:The sort of this PagedDiagnosticInformationMessages.
Return type:list[Order]
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

total_elements

Gets the total_elements of this PagedDiagnosticInformationMessages. The total amount of elements.

Returns:The total_elements of this PagedDiagnosticInformationMessages.
Return type:int
total_pages

Gets the total_pages of this PagedDiagnosticInformationMessages. The number of total pages.

Returns:The total_pages of this PagedDiagnosticInformationMessages.
Return type:int

mindconnect.models.paged_mapping module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class PagedMapping(content=None, last=None, total_pages=None, total_elements=None, number_of_elements=None, first=None, sort=None, size=None, number=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'content': 'content', 'first': 'first', 'last': 'last', 'number': 'number', 'number_of_elements': 'numberOfElements', 'size': 'size', 'sort': 'sort', 'total_elements': 'totalElements', 'total_pages': 'totalPages'}
attribute_types = {'content': 'list[Mapping]', 'first': 'bool', 'last': 'bool', 'number': 'int', 'number_of_elements': 'int', 'size': 'int', 'sort': 'list[Order]', 'total_elements': 'int', 'total_pages': 'int'}
content

Gets the content of this PagedMapping.

Returns:The content of this PagedMapping.
Return type:list[Mapping]
first

Gets the first of this PagedMapping. Whether the current item is the first one.

Returns:The first of this PagedMapping.
Return type:bool
last

Gets the last of this PagedMapping. Whether the current item is the last one.

Returns:The last of this PagedMapping.
Return type:bool
number

Gets the number of this PagedMapping. The number of the current item.

Returns:The number of this PagedMapping.
Return type:int
number_of_elements

Gets the number_of_elements of this PagedMapping. The number of elements currently on this page.

Returns:The number_of_elements of this PagedMapping.
Return type:int
size

Gets the size of this PagedMapping. The size of the page.

Returns:The size of this PagedMapping.
Return type:int
sort

Gets the sort of this PagedMapping. The sorting parameters for the page.

Returns:The sort of this PagedMapping.
Return type:list[Order]
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

total_elements

Gets the total_elements of this PagedMapping. The total amount of elements.

Returns:The total_elements of this PagedMapping.
Return type:int
total_pages

Gets the total_pages of this PagedMapping. The number of total pages.

Returns:The total_pages of this PagedMapping.
Return type:int

mindconnect.models.paged_recoverable_records module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class PagedRecoverableRecords(content=None, last=None, total_pages=None, total_elements=None, number_of_elements=None, first=None, sort=None, size=None, number=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'content': 'content', 'first': 'first', 'last': 'last', 'number': 'number', 'number_of_elements': 'numberOfElements', 'size': 'size', 'sort': 'sort', 'total_elements': 'totalElements', 'total_pages': 'totalPages'}
attribute_types = {'content': 'list[RecoverableRecords]', 'first': 'bool', 'last': 'bool', 'number': 'int', 'number_of_elements': 'int', 'size': 'int', 'sort': 'list[Order]', 'total_elements': 'int', 'total_pages': 'int'}
content

Gets the content of this PagedRecoverableRecords.

Returns:The content of this PagedRecoverableRecords.
Return type:list[RecoverableRecords]
first

Gets the first of this PagedRecoverableRecords. Whether the current item is the first one.

Returns:The first of this PagedRecoverableRecords.
Return type:bool
last

Gets the last of this PagedRecoverableRecords. Whether the current item is the last one.

Returns:The last of this PagedRecoverableRecords.
Return type:bool
number

Gets the number of this PagedRecoverableRecords. The number of the current item.

Returns:The number of this PagedRecoverableRecords.
Return type:int
number_of_elements

Gets the number_of_elements of this PagedRecoverableRecords. The number of elements currently on this page.

Returns:The number_of_elements of this PagedRecoverableRecords.
Return type:int
size

Gets the size of this PagedRecoverableRecords. The size of the page.

Returns:The size of this PagedRecoverableRecords.
Return type:int
sort

Gets the sort of this PagedRecoverableRecords. The sorting parameters for the page.

Returns:The sort of this PagedRecoverableRecords.
Return type:list[Order]
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

total_elements

Gets the total_elements of this PagedRecoverableRecords. The total amount of elements.

Returns:The total_elements of this PagedRecoverableRecords.
Return type:int
total_pages

Gets the total_pages of this PagedRecoverableRecords. The number of total pages.

Returns:The total_pages of this PagedRecoverableRecords.
Return type:int

mindconnect.models.pay_load_too_large module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class PayLoadTooLarge(id=None, message=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'id': 'id', 'message': 'message'}
attribute_types = {'id': 'str', 'message': 'str'}
id

Gets the id of this PayLoadTooLarge.

Returns:The id of this PayLoadTooLarge.
Return type:str
message

Gets the message of this PayLoadTooLarge.

Returns:The message of this PayLoadTooLarge.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.recoverable_records module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class RecoverableRecords(id=None, correlation_id=None, agent_id=None, request_time=None, drop_reason=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
agent_id

Gets the agent_id of this RecoverableRecords. agentId

Returns:The agent_id of this RecoverableRecords.
Return type:str
attribute_map = {'agent_id': 'agentId', 'correlation_id': 'correlationId', 'drop_reason': 'dropReason', 'id': 'id', 'request_time': 'requestTime'}
attribute_types = {'agent_id': 'str', 'correlation_id': 'str', 'drop_reason': 'str', 'id': 'str', 'request_time': 'datetime'}
correlation_id

Gets the correlation_id of this RecoverableRecords. Unique identifier of the record

Returns:The correlation_id of this RecoverableRecords.
Return type:str
drop_reason

Gets the drop_reason of this RecoverableRecords. Drop reason of data

Returns:The drop_reason of this RecoverableRecords.
Return type:str
id

Gets the id of this RecoverableRecords. Unique identifier of the record

Returns:The id of this RecoverableRecords.
Return type:str
request_time

Gets the request_time of this RecoverableRecords. Ingestion date of the data.

Returns:The request_time of this RecoverableRecords.
Return type:datetime
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.recoverable_records_get_request module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class RecoverableRecordsGetRequest(filter=None, size=None, page=None, sort=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'filter': 'filter', 'page': 'page', 'size': 'size', 'sort': 'sort'}
attribute_types = {'filter': 'str', 'page': 'int', 'size': 'int', 'sort': 'str'}
filter

Gets the filter of this RecoverableRecordsGetRequest.

Returns:The filter of this RecoverableRecordsGetRequest.
Return type:str
page

Gets the page of this RecoverableRecordsGetRequest.

Returns:The page of this RecoverableRecordsGetRequest.
Return type:int
size

Gets the size of this RecoverableRecordsGetRequest.

Returns:The size of this RecoverableRecordsGetRequest.
Return type:int
sort

Gets the sort of this RecoverableRecordsGetRequest.

Returns:The sort of this RecoverableRecordsGetRequest.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.recoverable_records_id_delete_request module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class RecoverableRecordsIdDeleteRequest(id=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'id': 'id'}
attribute_types = {'id': 'str'}
id

Gets the id of this RecoverableRecordsIdDeleteRequest.

Returns:The id of this RecoverableRecordsIdDeleteRequest.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.recoverable_records_id_replay_post_request module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class RecoverableRecordsIdReplayPostRequest(id=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'id': 'id'}
attribute_types = {'id': 'str'}
id

Gets the id of this RecoverableRecordsIdReplayPostRequest.

Returns:The id of this RecoverableRecordsIdReplayPostRequest.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.unauthorized module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class Unauthorized(id=None, message=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'id': 'id', 'message': 'message'}
attribute_types = {'id': 'str', 'message': 'str'}
id

Gets the id of this Unauthorized.

Returns:The id of this Unauthorized.
Return type:str
message

Gets the message of this Unauthorized.

Returns:The message of this Unauthorized.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

mindconnect.models.validity module

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501
class Validity(status=None, reasons=None)[source]

Bases: object

Attributes:
attribute_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
attribute_map = {'reasons': 'reasons', 'status': 'status'}
attribute_types = {'reasons': 'list[str]', 'status': 'str'}
reasons

Gets the reasons of this Validity.

Returns:The reasons of this Validity.
Return type:list[str]
status

Gets the status of this Validity.

Returns:The status of this Validity.
Return type:str
to_dict()[source]

Returns the model properties as a dict

to_str()[source]

Returns the string representation of the model

Module contents

MindConnect API

MindConnect API provides following data ingestion functionalities: # Data Point Mappings Creating and managing mappings between an agent’s data points and an entity’s dynamic property to be able to upload TimeSeries data. Each agent has data points with unique ids. The mapping is between to this id to an entity’s dynamic property set’s property. - A data point can be mapped to many property of many property set of many entities. - A property cannot be mapped from more than one data point. - A propertyset can have mappings from many agents’ many data points to its properties. - The unit of the datapoint has to be same with the unit of the property. - The type of the datapoint has to be same with the type of the property. Whenever data source configuration of an agent is updated via Agent Management API; all mappings with __keepMapping__ attribute set gets their validity attribute updated and all mappings with __keepMapping__ attribute unset are deleted. # Exchange Exchanging time series, events, files and data source configuration data. Combination of different data types can be uploaded via exchange endpoint within multipart body. Maximum size of exchange body is 10MBs. # Diagnostic Activations Management of Diagnostic Activations and querying Diagnostic Messages of time series, event, file and data source configuration requests. - Maximum 5 agents per tenant can be activated for data ingestion tracking. - For non-agents, the required permission allows to manage diagnostic activation resources of agents in the same tenant as in the token. - For agents, only the diagnostic activation related to the agent can be managed. Agents are forbidden to view/change the resources of other agents in the same tenant. - Agents are allowed to update activation for itself only. Users with sufficient scopes are allowed # noqa: E501