bely-api 2025.3.dev0__tar.gz

bely_api-2025.3.dev0/BelyApiFactory.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python
+
+# Copyright (c) UChicago Argonne, LLC. All rights reserved.
+# See LICENSE file.
+import base64
+import os
+
+from belyApi import Configuration, ApiClient
+from belyApi import (
+    DomainApi,
+    DownloadsApi,
+    UsersApi,
+    PropertyValueApi,
+    SystemLogApi,
+    SearchApi,
+    AuthenticationApi,
+    LogbookApi,
+    NotificationConfigurationApi,
+)
+from belyApi import ApiExceptionMessage
+
+
+class BelyApiFactory:
+
+    HEADER_TOKEN_KEY = "token"
+    URL_FORMAT = "%s/views/item/view?id=%s"
+
+    LOGBOOK_DOMAIN_ID = 1
+
+    def __init__(self, bely_url):
+        self.bely_url = bely_url
+        self.config = Configuration(host=self.bely_url)
+        self.api_client = ApiClient(configuration=self.config)
+
+        self.logbook_api = LogbookApi(api_client=self.api_client)
+        self.notification_configuration_api = NotificationConfigurationApi(
+            api_client=self.api_client
+        )
+
+        self.downloadsApi = DownloadsApi(api_client=self.api_client)
+        self.propertyValueApi = PropertyValueApi(api_client=self.api_client)
+        self.usersApi = UsersApi(api_client=self.api_client)
+        self.domainApi = DomainApi(api_client=self.api_client)
+
+        self.systemlogApi = SystemLogApi(api_client=self.api_client)
+        self.searchApi = SearchApi(api_client=self.api_client)
+
+        self.auth_api = AuthenticationApi(api_client=self.api_client)
+
+    def get_lobook_api(self) -> LogbookApi:
+        return self.logbook_api
+
+    def getDomainApi(self) -> DomainApi:
+        return self.domainApi
+
+    def getDownloadApi(self) -> DownloadsApi:
+        return self.downloadsApi
+
+    def getPropertyValueApi(self) -> PropertyValueApi:
+        return self.propertyValueApi
+
+    def getUsersApi(self) -> UsersApi:
+        return self.usersApi
+
+    def getSearchApi(self) -> SearchApi:
+        return self.searchApi
+
+    def getNotificationConfigurationApi(self):
+        return self.notification_configuration_api
+
+    def generateCDBUrlForItemId(self, itemId):
+        return self.URL_FORMAT % (self.cdbUrl, str(itemId))
+
+    def authenticate_user(self, username, password):
+        response = self.auth_api.authenticate_user_with_http_info(
+            username=username, password=password
+        )
+
+        token = response[-1][self.HEADER_TOKEN_KEY]
+        self.__set_authenticate_token(token)
+
+    def __set_authenticate_token(self, token):
+        self.api_client.set_default_header(self.HEADER_TOKEN_KEY, token)
+
+    def getAuthenticateToken(self):
+        return self.apiClient.default_headers[self.HEADER_TOKEN_KEY]
+
+    def test_authenticated(self):
+        self.auth_api.verify_authenticated()
+
+    def logout_user(self):
+        self.auth_api.log_out()
+
+    # Restore later
+    # @classmethod
+    # def createFileUploadObject(cls, filePath):
+    # 	data = open(filePath, "rb").read()
+    # 	b64String = base64.b64encode(data).decode()
+
+    # 	fileName = os.path.basename(filePath)
+    # 	return FileUploadObject(file_name=fileName, base64_binary=b64String)
+
+    def parseApiException(self, openApiException):
+        responseType = ApiExceptionMessage.__name__
+        openApiException.data = openApiException.body
+        exObj = self.apiClient.deserialize(openApiException, responseType)
+        exObj.status = openApiException.status
+        return exObj
+
+
+# def run_command():
+# Example
+# 	print("\nEnter cdb URL (ex: https://cdb.aps.anl.gov/cdb): ")
+# 	hostname = input()
+
+# 	apiFactory = CdbApiFactory(hostname)
+# 	itemApi = apiFactory.getItemApi()
+
+# 	catalogItems = itemApi.get_catalog_items()
+# 	catalogItem = catalogItems[0]
+
+# 	# Lists of items seem to be lists of dict items
+# 	catalogId = catalogItem.id
+
+# 	# Single items seem to be appropriate type
+# 	catalogFetchedById = itemApi.get_item_by_id(catalogId)
+# 	print(catalogFetchedById.name)
+
+# 	inventoryItemPerCatalog = itemApi.get_items_derived_from_item_by_item_id(catalogId)
+# 	print(inventoryItemPerCatalog)
+
+# 	print("\n\n\nWould you like to test authentication? (y/N): ")
+# 	resp = input()
+# 	if resp == 'y' or resp == "Y":
+# 		import getpass
+# 		print("Username: ")
+# 		username = input()
+# 		print("Password: ")
+# 		password = getpass.getpass()
+
+# 		try:
+# 			apiFactory.authenticateUser(username, password)
+# 			apiFactory.testAuthenticated()
+# 			apiFactory.logOutUser()
+# 		except ApiException:
+# 			print("Authentication failed!")
+# 			exit(1)
+
+# 		print("Success!")
+
+if __name__ == "__main__":
+    pass
+# 	run_command()

bely_api-2025.3.dev0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.1
+Name: bely_api
+Version: 2025.3.dev0
+Summary: Python client API library used to communicate with BELY API.
+Home-page: https://git.aps.anl.gov/controls/hla/bely
+Maintainer: Dariusz Jarosz
+Maintainer-email: djarosz@aps.anl.gov
+License: Copyright (c) UChicago Argonne, LLC. All rights reserved.

bely_api-2025.3.dev0/belyApi/__init__.py

@@ -0,0 +1,96 @@
+# coding: utf-8
+
+# flake8: noqa
+
+"""
+    BELY API
+
+    The API that provides access to BELY data.  # noqa: E501
+
+    The version of the OpenAPI document: 2024.5
+    Contact: djarosz@anl.gov
+    Generated by: https://openapi-generator.tech
+"""
+
+
+from __future__ import absolute_import
+
+__version__ = "1.0.0"
+
+# import apis into sdk package
+from belyApi.api.authentication_api import AuthenticationApi
+from belyApi.api.downloads_api import DownloadsApi
+from belyApi.api.logbook_api import LogbookApi
+from belyApi.api.notification_configuration_api import NotificationConfigurationApi
+from belyApi.api.property_value_api import PropertyValueApi
+from belyApi.api.search_api import SearchApi
+from belyApi.api.system_log_api import SystemLogApi
+from belyApi.api.test_api import TestApi
+from belyApi.api.users_api import UsersApi
+from belyApi.api.domain_api import DomainApi
+
+# import ApiClient
+from belyApi.api_client import ApiClient
+from belyApi.configuration import Configuration
+from belyApi.exceptions import OpenApiException
+from belyApi.exceptions import ApiTypeError
+from belyApi.exceptions import ApiValueError
+from belyApi.exceptions import ApiKeyError
+from belyApi.exceptions import ApiException
+# import models into sdk package
+from belyApi.models.allowed_property_value import AllowedPropertyValue
+from belyApi.models.api_exception_message import ApiExceptionMessage
+from belyApi.models.api_exception_message_exception import ApiExceptionMessageException
+from belyApi.models.api_exception_message_exception_cause import ApiExceptionMessageExceptionCause
+from belyApi.models.api_exception_message_exception_cause_stack_trace import ApiExceptionMessageExceptionCauseStackTrace
+from belyApi.models.api_exception_message_exception_cause_suppressed import ApiExceptionMessageExceptionCauseSuppressed
+from belyApi.models.cdb_entity import CdbEntity
+from belyApi.models.connector import Connector
+from belyApi.models.connector_type import ConnectorType
+from belyApi.models.domain import Domain
+from belyApi.models.entity_info import EntityInfo
+from belyApi.models.entity_type import EntityType
+from belyApi.models.inline_object import InlineObject
+from belyApi.models.item import Item
+from belyApi.models.item_category import ItemCategory
+from belyApi.models.item_connector import ItemConnector
+from belyApi.models.item_domain_logbook import ItemDomainLogbook
+from belyApi.models.item_domain_logbook_all_of import ItemDomainLogbookAllOf
+from belyApi.models.item_element import ItemElement
+from belyApi.models.item_element_history import ItemElementHistory
+from belyApi.models.item_element_relationship import ItemElementRelationship
+from belyApi.models.item_element_relationship_history import ItemElementRelationshipHistory
+from belyApi.models.item_project import ItemProject
+from belyApi.models.item_resource import ItemResource
+from belyApi.models.item_source import ItemSource
+from belyApi.models.item_type import ItemType
+from belyApi.models.list_tbl import ListTbl
+from belyApi.models.log import Log
+from belyApi.models.log_document_options import LogDocumentOptions
+from belyApi.models.log_document_section import LogDocumentSection
+from belyApi.models.log_entry import LogEntry
+from belyApi.models.log_reaction import LogReaction
+from belyApi.models.notification_configuration import NotificationConfiguration
+from belyApi.models.notification_configuration_handler_setting import NotificationConfigurationHandlerSetting
+from belyApi.models.notification_configuration_setting import NotificationConfigurationSetting
+from belyApi.models.notification_handler_config_key import NotificationHandlerConfigKey
+from belyApi.models.notification_provider import NotificationProvider
+from belyApi.models.notification_provider_config_key import NotificationProviderConfigKey
+from belyApi.models.property_metadata import PropertyMetadata
+from belyApi.models.property_type import PropertyType
+from belyApi.models.property_value import PropertyValue
+from belyApi.models.property_value_history import PropertyValueHistory
+from belyApi.models.reaction import Reaction
+from belyApi.models.relationship_type import RelationshipType
+from belyApi.models.relationship_type_handler import RelationshipTypeHandler
+from belyApi.models.resource_type import ResourceType
+from belyApi.models.resource_type_category import ResourceTypeCategory
+from belyApi.models.role_type import RoleType
+from belyApi.models.search_entities_options import SearchEntitiesOptions
+from belyApi.models.search_entities_results import SearchEntitiesResults
+from belyApi.models.search_result import SearchResult
+from belyApi.models.source import Source
+from belyApi.models.user_group import UserGroup
+from belyApi.models.user_info import UserInfo
+from belyApi.models.user_role import UserRole
+

bely_api-2025.3.dev0/belyApi/api/__init__.py

@@ -0,0 +1,15 @@
+from __future__ import absolute_import
+
+# flake8: noqa
+
+# import apis into api package
+from belyApi.api.authentication_api import AuthenticationApi
+from belyApi.api.downloads_api import DownloadsApi
+from belyApi.api.logbook_api import LogbookApi
+from belyApi.api.notification_configuration_api import NotificationConfigurationApi
+from belyApi.api.property_value_api import PropertyValueApi
+from belyApi.api.search_api import SearchApi
+from belyApi.api.system_log_api import SystemLogApi
+from belyApi.api.test_api import TestApi
+from belyApi.api.users_api import UsersApi
+from belyApi.api.domain_api import DomainApi

bely_api-2025.3.dev0/belyApi/api/authentication_api.py

@@ -0,0 +1,357 @@
+# coding: utf-8
+
+"""
+    BELY API
+
+    The API that provides access to BELY data.  # noqa: E501
+
+    The version of the OpenAPI document: 2024.5
+    Contact: djarosz@anl.gov
+    Generated by: https://openapi-generator.tech
+"""
+
+
+from __future__ import absolute_import
+
+import re  # noqa: F401
+
+# python 2 and python 3 compatibility library
+import six
+
+from belyApi.api_client import ApiClient
+from belyApi.exceptions import (  # noqa: F401
+    ApiTypeError,
+    ApiValueError
+)
+
+
+class AuthenticationApi(object):
+    """NOTE: This class is auto generated by OpenAPI Generator
+    Ref: https://openapi-generator.tech
+
+    Do not edit the class manually.
+    """
+
+    def __init__(self, api_client=None):
+        if api_client is None:
+            api_client = ApiClient()
+        self.api_client = api_client
+
+    def authenticate_user(self, **kwargs):  # noqa: E501
+        """Logs user into the system  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.authenticate_user(async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str username:
+        :param str password:
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: None
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.authenticate_user_with_http_info(**kwargs)  # noqa: E501
+
+    def authenticate_user_with_http_info(self, **kwargs):  # noqa: E501
+        """Logs user into the system  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.authenticate_user_with_http_info(async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str username:
+        :param str password:
+        :param _return_http_data_only: response data without head status code
+                                       and headers
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: None
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+            'username',
+            'password'
+        ]
+        all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout'
+            ]
+        )
+
+        for key, val in six.iteritems(local_var_params['kwargs']):
+            if key not in all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method authenticate_user" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+        if 'username' in local_var_params:
+            form_params.append(('username', local_var_params['username']))  # noqa: E501
+        if 'password' in local_var_params:
+            form_params.append(('password', local_var_params['password']))  # noqa: E501
+
+        body_params = None
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/x-www-form-urlencoded'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = []  # noqa: E501
+
+        return self.api_client.call_api(
+            '/api/auth/login', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type=None,  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=local_var_params.get('async_req'),
+            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=local_var_params.get('_preload_content', True),
+            _request_timeout=local_var_params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def log_out(self, **kwargs):  # noqa: E501
+        """log_out  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.log_out(async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: None
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.log_out_with_http_info(**kwargs)  # noqa: E501
+
+    def log_out_with_http_info(self, **kwargs):  # noqa: E501
+        """log_out  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.log_out_with_http_info(async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param _return_http_data_only: response data without head status code
+                                       and headers
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: None
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+        ]
+        all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout'
+            ]
+        )
+
+        for key, val in six.iteritems(local_var_params['kwargs']):
+            if key not in all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method log_out" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['*/*'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = []  # noqa: E501
+
+        return self.api_client.call_api(
+            '/api/auth/logout', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type=None,  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=local_var_params.get('async_req'),
+            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=local_var_params.get('_preload_content', True),
+            _request_timeout=local_var_params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def verify_authenticated(self, **kwargs):  # noqa: E501
+        """verify_authenticated  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.verify_authenticated(async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: bool
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.verify_authenticated_with_http_info(**kwargs)  # noqa: E501
+
+    def verify_authenticated_with_http_info(self, **kwargs):  # noqa: E501
+        """verify_authenticated  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.verify_authenticated_with_http_info(async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param _return_http_data_only: response data without head status code
+                                       and headers
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: tuple(bool, status_code(int), headers(HTTPHeaderDict))
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+        ]
+        all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout'
+            ]
+        )
+
+        for key, val in six.iteritems(local_var_params['kwargs']):
+            if key not in all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method verify_authenticated" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = ['belyAuth']  # noqa: E501
+
+        return self.api_client.call_api(
+            '/api/auth/Verify', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='bool',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=local_var_params.get('async_req'),
+            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=local_var_params.get('_preload_content', True),
+            _request_timeout=local_var_params.get('_request_timeout'),
+            collection_formats=collection_formats)