abap-adt-py 0.1.0__tar.gz

abap_adt_py-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 timkoehne
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

abap_adt_py-0.1.0/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: abap-adt-py
+Version: 0.1.0
+Summary: A Python library for interacting with SAP systems using the ADT (ABAP Development Tools) protocol.
+Author-email: Tim Köhne <20153452+timkoehne@users.noreply.github.com>
+License: MIT License
+        
+        Copyright (c) 2023 timkoehne
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Homepage, https://github.com/timkoehne/abap-adt-py
+Project-URL: Bug Tracker, https://github.com/timkoehne/abap-adt-py/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25
+Requires-Dist: typing-extensions>=4.7.1
+Dynamic: license-file

abap_adt_py-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "abap-adt-py"
+version = "0.1.0"
+description = "A Python library for interacting with SAP systems using the ADT (ABAP Development Tools) protocol."
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [
+  { name = "Tim Köhne", email = "20153452+timkoehne@users.noreply.github.com" }
+]
+requires-python = ">=3.7"
+dependencies = [
+  "requests>=2.25",
+  "typing-extensions>=4.7.1",
+]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.7",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/timkoehne/abap-adt-py"
+"Bug Tracker" = "https://github.com/timkoehne/abap-adt-py/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

abap_adt_py-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

abap_adt_py-0.1.0/src/abap_adt_py/adt_client.py

@@ -0,0 +1,131 @@
+import requests
+from requests.auth import HTTPBasicAuth
+
+from .compat_typing import Literal, List, Dict
+from .api.prettyprint import PrettyPrintSettings, prettyprint, set_pretty_printer_settings
+from .api.create import create, create_test_class_include
+from .api.activate import activate
+from .api.create import ObjectTypes
+from .api.delete import delete
+from .api.lock import lock, unlock
+from .api.login import login
+from .api.content import get_object_source, set_object_source
+from .api.search import search_object
+from .api.unittest import UnitTestAlert, UnittestFlags, run_unit_test
+from .http_request import HttpRequestParameters
+
+
+class AdtClient:
+    sap_host: str
+    csrf_token: str = "fetch"
+    request_number: int = 0
+    statefulness: Literal["stateless", "stateful"] = "stateless"
+
+    def __init__(
+        self, sap_host: str, username: str, password: str, client: str, language: str
+    ):
+        self.username = username
+        self.session = requests.Session()
+        self.session.auth = HTTPBasicAuth(username, password)
+        self.sap_host = sap_host
+        self.client = client
+        self.language = language
+
+    def build_request_parameters(self) -> HttpRequestParameters:
+        http_request_parameters: HttpRequestParameters = {
+            "host": self.sap_host,
+            "csrf_token": self.csrf_token,
+            "statefulness": self.statefulness,
+            "request_number": self.request_number,
+            "session": self.session,
+        }
+        self.request_number += 1
+        return http_request_parameters
+
+    def login(self) -> bool:
+        http_request_parameters = self.build_request_parameters()
+        csrf_token = login(http_request_parameters)
+        if csrf_token:
+            self.csrf_token = csrf_token
+            return True
+        else:
+            raise Exception("Login failed.")
+
+    def search_object(self, query: str, max_results: int = 1) -> List[Dict[str, str]]:
+        http_request_parameters = self.build_request_parameters()
+        elements = search_object(http_request_parameters, query, max_results)
+        return elements
+
+    def get_object_source(
+        self, object_uri: str, version: Literal["active", "inactive"] = "active"
+    ) -> str:
+        http_request_parameters = self.build_request_parameters()
+        response = get_object_source(http_request_parameters, object_uri, version)
+        return response
+
+    def activate(self, object_name: str, object_uri: str) -> bool:
+        http_request_parameters = self.build_request_parameters()
+        response = activate(http_request_parameters, object_name, object_uri)
+        return response
+
+    def lock(self, object_uri: str) -> str:
+        self.statefulness = "stateful"
+        http_request_parameters = self.build_request_parameters()
+        response = lock(http_request_parameters, object_uri)
+        return response
+
+    def unlock(self, object_uri: str, lock_handle: str) -> bool:
+        http_request_parameters = self.build_request_parameters()
+        response = unlock(http_request_parameters, object_uri, lock_handle)
+        self.statefulness = "stateless"
+        return response
+
+    def set_object_source(
+        self, object_uri: str, source_code: str, lock_handle: str
+    ) -> bool:
+        http_request_parameters = self.build_request_parameters()
+        response = set_object_source(
+            http_request_parameters, object_uri, source_code, lock_handle
+        )
+        return response
+
+    def run_unit_test(
+        self, object_uri: str, unit_test_flags: UnittestFlags = UnittestFlags()
+    ) -> List[UnitTestAlert]:
+        http_request_parameters = self.build_request_parameters()
+        response = run_unit_test(http_request_parameters, object_uri, unit_test_flags)
+        return response
+
+    def delete(self, object_uri: str, lock_handle: str) -> bool:
+        http_request_parameters = self.build_request_parameters()
+        response = delete(http_request_parameters, object_uri, lock_handle)
+        return response
+
+    def create(
+        self, object_type: ObjectTypes, name: str, parent: str, description: str
+    ) -> bool:
+        http_request_parameters = self.build_request_parameters()
+        response = create(
+            http_request_parameters,
+            object_type,
+            name,
+            parent,
+            description,
+            self.username,
+        )
+        return response
+
+    def create_test_class_include(self, class_name: str, lock_handle: str) -> bool:
+        http_request_parameters = self.build_request_parameters()
+        response = create_test_class_include(http_request_parameters, class_name, lock_handle)
+        return response
+    
+    def prettyprint(self, src: str) -> str:
+        http_request_parameters = self.build_request_parameters()
+        response = prettyprint(http_request_parameters, src)
+        return response
+    
+    def prettyprint_settings(self, settings: PrettyPrintSettings) -> bool:
+        http_request_parameters = self.build_request_parameters()
+        response = set_pretty_printer_settings(http_request_parameters, settings)
+        return response

abap_adt_py-0.1.0/src/abap_adt_py/api/activate.py

@@ -0,0 +1,33 @@
+from ..http_request import HttpRequestParameters, request
+from ..response_parsing import find_xml_element_attributes, find_xml_elements_attributes
+
+
+def activate(
+    http_request_parameters: HttpRequestParameters, object_name: str, object_uri: str
+) -> bool:
+
+    body = f"""
+    <?xml version="1.0" encoding="UTF-8"?>
+    <adtcore:objectReferences xmlns:adtcore="http://www.sap.com/adt/core">
+        <adtcore:objectReference adtcore:uri="{object_uri}" adtcore:name="{object_name}"/>
+    </adtcore:objectReferences>
+    """
+
+    response = request(
+        http_request_parameters,
+        uri="/sap/bc/adt/activation",
+        params={"method": "activate", "preauditRequested": "true"},
+        body=body,
+        method="POST",
+        content_type="application/xml",
+    )
+    print(response.text)
+    properties = find_xml_element_attributes(response.text, "chkl:properties")
+    if (
+        properties["activationExecuted"] == "true"
+        or properties["generationExecuted"] == "true"
+    ):
+        return True
+    else:
+        msg_elements = find_xml_elements_attributes(response.text, "msg")
+        raise Exception(f"{response.status_code} - Activation failed.\n{msg_elements}")

abap_adt_py-0.1.0/src/abap_adt_py/api/content.py

@@ -0,0 +1,52 @@
+from ..compat_typing import Literal
+from ..http_request import HttpRequestParameters, request
+
+
+def get_object_source(
+    http_request_parameters: HttpRequestParameters,
+    object_uri: str,
+    version: Literal["active", "inactive"] = "active",
+) -> str:
+
+    params = {}
+    if version:
+        params["version"] = version
+
+    response = request(
+        http_request_parameters=http_request_parameters,
+        uri=object_uri,
+        method="GET",
+        body="",
+        params=params,
+        content_type="application/xml",
+    )
+
+    if response.status_code == 200:
+        return response.text
+    else:
+        raise Exception(
+            f"{response.status_code} - Failed to get object source.\n{response.text}"
+        )
+
+
+def set_object_source(
+    http_request_parameters: HttpRequestParameters,
+    object_uri: str,
+    source_code: str,
+    lock_handle: str,
+) -> bool:
+    response = request(
+        http_request_parameters=http_request_parameters,
+        uri=object_uri,
+        method="PUT",
+        body=source_code,
+        params={"lockHandle": lock_handle},
+        content_type="text/plain; charset=utf-8",
+    )
+
+    if response.status_code == 200:
+        return True
+    else:
+        raise Exception(
+            f"{response.status_code} - Failed to set source code for {object_uri}\n{response.text}"
+        )

abap_adt_py-0.1.0/src/abap_adt_py/api/create.py

@@ -0,0 +1,181 @@
+from ..compat_typing import Literal, TypeAlias, Dict, TypedDict
+from ..http_request import HttpRequestParameters, request
+
+
+class CreateableTypeDetails(TypedDict):
+    path: str
+    xml_name: str
+    xml_namespace: str
+
+
+ObjectTypes: TypeAlias = Literal[
+    "PROG/P",
+    "CLAS/OC",
+    "TABL/DT",
+    "INTF/OI",
+    "PROG/I",
+    "FUGR/F",
+    "FUGR/FF",
+    "MSAG/N",
+    "DCLS/DL",
+    "DDLS/DF",
+    "DDLX/EX",
+    "DTEL/DE",
+]
+
+CreateableTypes: TypeAlias = Dict[ObjectTypes, CreateableTypeDetails]
+CREATEABLE_TYPES: CreateableTypes = {
+    "PROG/P": {
+        "path": "/sap/bc/adt/programs/programs",
+        "xml_name": "program:abapProgram",
+        "xml_namespace": 'xmlns:program="http://www.sap.com/adt/programs/programs"',
+    },
+    "CLAS/OC": {
+        "path": "/sap/bc/adt/oo/classes",
+        "xml_name": "class:abapClass",
+        "xml_namespace": 'xmlns:class="http://www.sap.com/adt/oo/classes"',
+    },
+    "TABL/DT": {
+        "path": "/sap/bc/adt/ddic/tables",
+        "xml_name": "blue:blueSource",
+        "xml_namespace": 'xmlns:blue="http://www.sap.com/wbobj/blue"',
+    },
+    "INTF/OI": {
+        "path": "/sap/bc/adt/oo/interfaces",
+        "xml_name": "intf:abapInterface",
+        "xml_namespace": 'xmlns:intf="http://www.sap.com/adt/oo/interfaces"',
+    },
+    "PROG/I": {
+        "path": "/sap/bc/adt/programs/includes",
+        "xml_name": "include:abapInclude",
+        "xml_namespace": 'xmlns:include="http://www.sap.com/adt/programs/includes"',
+    },
+    "FUGR/F": {
+        "path": "/sap/bc/adt/functions/groups",
+        "xml_name": "group:abapFunctionGroup",
+        "xml_namespace": 'xmlns:group="http://www.sap.com/adt/functions/groups"',
+    },
+    "FUGR/FF": {
+        "path": "/sap/bc/adt/functions/groups/{}/fmodules",
+        "xml_name": "fmodule:abapFunctionModule",
+        "xml_namespace": 'xmlns:fmodule="http://www.sap.com/adt/functions/fmodules"',
+    },
+    "MSAG/N": {
+        "path": "/sap/bc/adt/messageclass",
+        "xml_name": "mc:messageClass",
+        "xml_namespace": 'xmlns:mc="http://www.sap.com/adt/MessageClass"',
+    },
+    "DCLS/DL": {
+        "path": "/sap/bc/adt/acm/dcl/sources",
+        "xml_name": "dcl:dclSource",
+        "xml_namespace": 'xmlns:dcl="http://www.sap.com/adt/acm/dclsources"',
+    },
+    "DDLS/DF": {
+        "path": "/sap/bc/adt/ddic/ddl/sources",
+        "xml_name": "ddl:ddlSource",
+        "xml_namespace": 'xmlns:ddl="http://www.sap.com/adt/ddic/ddlsources"',
+    },
+    "DDLX/EX": {
+        "path": "/sap/bc/adt/ddic/ddlx/sources",
+        "xml_name": "ddlx:ddlxSource",
+        "xml_namespace": 'xmlns:ddlx="http://www.sap.com/adt/ddic/ddlxsources"',
+    },
+    "DTEL/DE": {
+        "path": "/sap/bc/adt/ddic/dataelements",
+        "xml_name": "blue:wbobj",
+        "xml_namespace": 'xmlns:blue="http://www.sap.com/wbobj/dictionary/dtel"',
+    },
+}
+
+
+def _build_body(
+    description: str, name: str, package: str, owner: str, object_type: ObjectTypes
+) -> str:
+
+    if object_type in ["FUGR/FF"]:
+        parent_ref = f"""
+        <adtcore:containerRef adtcore:name="{owner}" 
+            adtcore:type="FUGR/F"
+            adtcore:uri="{package}" />"""
+    else:
+        parent_ref = f"""
+        <adtcore:packageRef adtcore:name="{package}"/>
+        """
+
+    creatable_object = CREATEABLE_TYPES[object_type]
+
+    return f"""
+    <?xml version="1.0" encoding="UTF-8"?>
+    <{creatable_object["xml_name"]} {creatable_object["xml_namespace"]}
+        xmlns:adtcore="http://www.sap.com/adt/core"
+        adtcore:description="{description}"
+        adtcore:name="{name}" adtcore:type="{object_type}"
+        adtcore:responsible="{owner}" >
+    {parent_ref}
+    </{creatable_object["xml_name"]}>
+    """
+
+
+def create(
+    http_request_parameters: HttpRequestParameters,
+    object_type: ObjectTypes,
+    name: str,
+    parent: str,
+    description: str,
+    owner: str,
+) -> bool:
+
+    object_uri = CREATEABLE_TYPES[object_type]["path"]
+
+    # noop for most objects but eg. function modules need their function group in their object uri
+    object_uri = object_uri.format(parent)
+
+    body = _build_body(
+        description=description,
+        name=name,
+        package=parent,
+        object_type=object_type,
+        owner=owner,
+    )
+
+    response = request(
+        http_request_parameters=http_request_parameters,
+        uri=object_uri,
+        method="POST",
+        body=body,
+        params={},
+        content_type="application/*",
+    )
+
+    if 200 <= response.status_code <= 300:
+        return True
+    else:
+        raise Exception(
+            f"{response.status_code} - Failed to create object {name}\n{response.text}"
+        )
+
+
+def create_test_class_include(
+    http_request_parameters: HttpRequestParameters, class_name: str, lock_handle: str
+) -> bool:
+
+    body = f"""
+        <?xml version="1.0" encoding="UTF-8"?>
+        <class:abapClassInclude xmlns:class="http://www.sap.com/adt/oo/classes"
+            xmlns:adtcore="http://www.sap.com/adt/core" adtcore:name="{class_name}" class:includeType="testclasses"/>
+        """
+
+    response = request(
+        http_request_parameters=http_request_parameters,
+        uri=f"/sap/bc/adt/oo/classes/{class_name}/includes",
+        method="POST",
+        body=body,
+        params={"lockHandle": lock_handle},
+    )
+
+    if 200 <= response.status_code <= 300:
+        return True
+    else:
+        raise Exception(
+            f"{response.status_code} - Failed to create testclass for {class_name}\n{response.text}"
+        )

abap_adt_py-0.1.0/src/abap_adt_py/api/delete.py

@@ -0,0 +1,17 @@
+from ..http_request import HttpRequestParameters, request
+
+
+def delete(http_request_parameters: HttpRequestParameters, object_uri: str, lock_handle: str) -> bool:
+    response = request(
+        http_request_parameters=http_request_parameters,
+        uri=object_uri,
+        body="",
+        params={"lockHandle": lock_handle},
+        method="DELETE",
+    )
+    if response.status_code == 200:
+        return True
+    else:
+        raise Exception(
+            f"{response.status_code} Failed to delete {object_uri}.\n{response.text}"
+        )

abap_adt_py-0.1.0/src/abap_adt_py/api/lock.py

@@ -0,0 +1,38 @@
+from ..http_request import HttpRequestParameters, request
+from ..response_parsing import find_xml_element_text
+
+
+def lock(http_request_parameters: HttpRequestParameters, object_uri: str) -> str:
+    response = request(
+        http_request_parameters=http_request_parameters,
+        uri=object_uri,
+        body="",
+        params={"_action": "LOCK", "accessMode": "MODIFY"},
+        method="POST",
+    )
+    if response.status_code == 200:
+        lock_handle = find_xml_element_text(response.text, ".//LOCK_HANDLE")
+        return lock_handle
+    else:
+        raise Exception(
+            f"{response.status_code} Failed to lock {object_uri}.\n{response.text}"
+        )
+
+
+def unlock(
+    http_request_parameters: HttpRequestParameters, object_uri: str, lock_handle: str
+) -> bool:
+    response = request(
+        http_request_parameters=http_request_parameters,
+        uri=object_uri,
+        body="",
+        params={"_action": "UNLOCK", "lockHandle": lock_handle},
+        method="POST",
+        content_type="plain/text; charset=utf-8",
+    )
+    if response.status_code == 200:
+        return True
+    else:
+        raise Exception(
+            f"{response.status_code} Failed to unlock {object_uri}\n{response.text}"
+        )

abap_adt_py-0.1.0/src/abap_adt_py/api/login.py

@@ -0,0 +1,20 @@
+from ..http_request import HttpRequestParameters, request
+
+
+def login(http_request_parameters: HttpRequestParameters) -> str:
+
+    response = request(
+        http_request_parameters=http_request_parameters,
+        uri="/sap/bc/adt/compatibility/graph",
+        method="GET",
+        body="",
+        params={},
+    )
+
+    if response.status_code == 200:
+        csrf_token = response.headers.get("x-csrf-token")
+        if csrf_token is None:
+            raise Exception("CSRF token not found in response headers.")
+        return csrf_token
+    else:
+        raise Exception(f"{response.status_code} - Login failed.\n{response.text}")

abap_adt_py-0.1.0/src/abap_adt_py/api/prettyprint.py

@@ -0,0 +1,93 @@
+from ..compat_typing import Literal, NotRequired, TypedDict
+from ..http_request import HttpRequestParameters, request
+
+
+class PrettyPrintSettings(TypedDict):
+    indentation: bool
+    style: Literal[
+        "toLower", "toUpper", "keywordLower", "keywordUpper", "none", "keywordAuto"
+    ]
+    condense_method_calls: NotRequired[bool]
+    default_auto_style: NotRequired[Literal["keywordLower", "keywordUpper"]]
+    format_method_calls: NotRequired[bool]
+    keep_identifier: NotRequired[bool]
+
+
+def set_pretty_printer_settings(
+    http_request_parameters: HttpRequestParameters, settings: PrettyPrintSettings
+):
+
+    condense_method_calls = (
+        f"prettyprintersettings:condenseMethodCalls=\"{str(settings['condense_method_calls']).lower()}\""
+        if "condense_method_calls" in settings
+        else ""
+    )
+    default_auto_style = (
+        f"prettyprintersettings:defaultAutoStyle=\"{settings['default_auto_style']}\""
+        if "default_auto_style" in settings
+        else ""
+    )
+    format_method_calls = (
+        f"prettyprintersettings:formatMethodCalls=\"{str(settings['format_method_calls']).lower()}\""
+        if "format_method_calls" in settings
+        else ""
+    )
+    indentation = (
+        f"prettyprintersettings:indentation=\"{str(settings['indentation']).lower()}\""
+        if "indentation" in settings
+        else ""
+    )
+    keep_identifier = (
+        f"prettyprintersettings:keepIdentifier=\"{str(settings['keep_identifier']).lower()}\""
+        if "keep_identifier" in settings
+        else ""
+    )
+    style = (
+        f"prettyprintersettings:style=\"{settings['style']}\""
+        if "style" in settings
+        else ""
+    )
+
+    body = f"""<?xml version="1.0" encoding="UTF-8"?>
+    <prettyprintersettings:PrettyPrinterSettings 
+    xmlns:prettyprintersettings="http://www.sap.com/adt/prettyprintersettings"
+        {condense_method_calls}
+        {default_auto_style}
+        {format_method_calls}
+        {indentation}
+        {keep_identifier}
+        {style}
+        />
+        """
+
+    response = request(
+        http_request_parameters,
+        uri="/sap/bc/adt/abapsource/prettyprinter/settings",
+        params={},
+        body=body,
+        method="PUT",
+        content_type="application/xml",
+    )
+    if response.status_code == 200:
+        return True
+    else:
+        raise Exception(
+            f"{response.status_code} Failed to set prettyprint settings\n{response.text}"
+        )
+
+
+def prettyprint(http_request_parameters: HttpRequestParameters, src: str):
+    response = request(
+        http_request_parameters,
+        uri="/sap/bc/adt/abapsource/prettyprinter",
+        params={},
+        body=src,
+        method="POST",
+        content_type="text/plain; charset=utf-8",
+    )
+    if response.status_code == 200:
+        return response.text
+    else:
+        raise Exception(
+            f"{response.status_code} Failed to prettyprint\n{response.text}"
+        )

abap_adt_py-0.1.0/src/abap_adt_py/api/search.py

@@ -0,0 +1,18 @@
+from ..http_request import HttpRequestParameters, request
+from ..response_parsing import find_xml_elements_attributes
+from ..compat_typing import List, Dict
+
+
+def search_object(
+    http_request_parameters: HttpRequestParameters, query: str, max_results: int = 1
+) -> List[Dict[str, str]]:
+
+    response = request(
+        http_request_parameters=http_request_parameters,
+        uri="/sap/bc/adt/repository/informationsystem/search",
+        method="GET",
+        body="",
+        params={"operation": "quickSearch", "query": query, "maxResults": max_results},
+    )
+    elements = find_xml_elements_attributes(response.text, "adtcore:objectReference")
+    return elements

abap_adt_py-0.1.0/src/abap_adt_py/api/unittest.py

@@ -0,0 +1,101 @@
+import xml.etree.ElementTree as et
+
+from ..compat_typing import List, TypedDict
+from ..api.xml_namespaces import XML_NAMESPACES
+from ..http_request import HttpRequestParameters, request
+
+
+class UnittestFlags:
+    def __init__(
+        self,
+        harmless: bool = True,
+        dangerous: bool = False,
+        critical: bool = False,
+        short: bool = True,
+        medium: bool = False,
+        long: bool = False,
+    ):
+        self.harmless = harmless
+        self.dangerous = dangerous
+        self.critical = critical
+        self.short = short
+        self.medium = medium
+        self.long = long
+
+
+class UnitTestAlert(TypedDict):
+    title: str
+    kind: str
+    severity: str
+    details: List[str]
+
+
+def _parse_alerts(xml_text: str) -> List[UnitTestAlert]:
+    root = et.fromstring(xml_text)
+    errors = []
+    alerts = root.findall(".//alert", XML_NAMESPACES)
+    for alert in alerts:
+        a = {}
+        title = alert.find(".//title", XML_NAMESPACES)
+        a["title"] = title.text if title is not None else ""
+        a["kind"] = alert.attrib.get("kind", "")
+        a["severity"] = alert.attrib.get("severity", "")
+        stack = alert.find(".//stack", XML_NAMESPACES)
+        a["stack"] = stack if stack is not None else []
+        details = []
+        for detail in alert.findall("./details/detail", XML_NAMESPACES):
+            detail_str = "\n".join(
+                x.attrib["text"]
+                for x in detail.iter()
+                if "text" in x.attrib is not None
+            )
+            details.append(detail_str)
+        a["details"] = details
+        errors.append(a)
+    return errors
+
+
+def run_unit_test(
+    http_request_parameters: HttpRequestParameters,
+    object_uri: str,
+    unit_test_flags: UnittestFlags = UnittestFlags(),
+):
+    body = f"""
+        <?xml version="1.0" encoding="UTF-8"?>
+        <aunit:runConfiguration xmlns:aunit="http://www.sap.com/adt/aunit">
+        <external>
+            <coverage active="false"/>
+        </external>
+        <options>
+            <uriType value="semantic"/>
+            <testDeterminationStrategy sameProgram="true" assignedTests="false"/>
+            <testRiskLevels harmless="{str(unit_test_flags.harmless).lower()}" dangerous="{str(unit_test_flags.dangerous).lower()}" critical="{str(unit_test_flags.critical).lower()}"/>
+            <testDurations short="{str(unit_test_flags.short).lower()}" medium="{str(unit_test_flags.medium).lower()}" long="{str(unit_test_flags.long).lower()}"/>
+            <withNavigationUri enabled="true"/>    
+        </options>
+        <adtcore:objectSets xmlns:adtcore="http://www.sap.com/adt/core">
+            <objectSet kind="inclusive">
+            <adtcore:objectReferences>
+                <adtcore:objectReference adtcore:uri="{object_uri}"/>
+            </adtcore:objectReferences>
+            </objectSet>
+        </adtcore:objectSets>
+        </aunit:runConfiguration>
+        """
+
+    response = request(
+        http_request_parameters=http_request_parameters,
+        uri="/sap/bc/adt/abapunit/testruns",
+        method="POST",
+        body=body,
+        params={},
+        content_type="application/xml",
+    )
+    if response.status_code == 200:
+        alerts = _parse_alerts(response.text)
+        return alerts
+
+    else:
+        raise Exception(
+            f"{response.status_code} - Failed to run unit test for {object_uri}\n{response.text}"
+        )

abap_adt_py-0.1.0/src/abap_adt_py/api/xml_namespaces.py

@@ -0,0 +1,8 @@
+XML_NAMESPACES = {
+    "chkl": "http://www.sap.com/abapxml/checklist",
+    "atom": "http://www.w3.org/2005/Atom",
+    "adtcore": "http://www.sap.com/adt/core",
+    "exc": "http://www.sap.com/abapxml/types/communicationframework",
+    "asx": "http://www.sap.com/abapxml",
+    "aunit": "http://www.sap.com/adt/aunit",
+}

abap_adt_py-0.1.0/src/abap_adt_py/compat_typing.py

@@ -0,0 +1,14 @@
+try:
+    from typing import Literal, NotRequired, TypeAlias, Optional, Dict, List, TypedDict  # Python 3.11+
+except ImportError:
+    try:
+        from typing import Literal  # Python 3.8 - 3.10
+    except ImportError:
+        from typing_extensions import Literal  # Python 3.7 fallback
+
+    from typing_extensions import NotRequired
+    from typing_extensions import TypeAlias
+    from typing_extensions import Optional
+    from typing_extensions import Dict
+    from typing_extensions import List 
+    from typing_extensions import TypedDict

abap_adt_py-0.1.0/src/abap_adt_py/http_request.py

@@ -0,0 +1,46 @@
+import requests
+from .compat_typing import Literal, TypedDict
+
+
+class HttpRequestParameters(TypedDict):
+    host: str
+    csrf_token: str
+    statefulness: Literal["stateless", "stateful"]
+    request_number: int
+    session: requests.Session
+
+
+def request(
+    http_request_parameters: HttpRequestParameters,
+    uri: str,
+    method: Literal["GET", "POST", "PUT", "DELETE"],
+    body: str,
+    params: dict,
+    content_type: str = "application/xml",
+) -> requests.Response:
+
+    config = {
+        "params": params,
+        "headers": {
+            "Accept": "*/*",
+            "Cache-Control": "no-cache",
+            "x-csrf-token": http_request_parameters["csrf_token"],
+            "X-sap-adt-sessiontype": http_request_parameters["statefulness"],
+            "content-type": content_type,
+        },
+        "url": http_request_parameters["host"] + uri,
+        "data": body,
+    }
+
+    session = http_request_parameters["session"]
+    if method == "POST":
+        response = session.post(**config)
+    elif method == "GET":
+        response = session.get(**config)
+    elif method == "PUT":
+        response = session.put(**config)
+    elif method == "DELETE":
+        response = session.delete(**config)
+    else:
+        raise ValueError(f"Unsupported method: {method}")
+    return response

abap_adt_py-0.1.0/src/abap_adt_py/response_parsing.py

@@ -0,0 +1,43 @@
+from xml.etree import ElementTree as et
+from .compat_typing import Optional, Dict, List
+from .api.xml_namespaces import XML_NAMESPACES
+
+
+def _strip_namespace(name: str) -> str:
+    if name.startswith("{"):
+        return name.split("}", 1)[1]
+    if ":" in name:
+        return name.split(":", 1)[1]
+    return name
+
+
+def _et_to_attributes_dict(element: Optional[et.Element]) -> Dict[str, str]:
+    cleaned = (
+        {_strip_namespace(key): value for key, value in element.attrib.items()}
+        if element is not None
+        else {}
+    )
+    return cleaned
+
+
+def find_xml_elements_attributes(xml_text: str, tag_name: str) -> List[Dict[str, str]]:
+    root = et.fromstring(xml_text)
+    elements = root.findall(tag_name, XML_NAMESPACES)
+    processed_elements = []
+    for element in elements:
+        cleaned = _et_to_attributes_dict(element)
+        processed_elements.append(cleaned)
+    return processed_elements
+
+
+def find_xml_element_attributes(xml_text: str, tag_name: str) -> Dict[str, str]:
+    root = et.fromstring(xml_text)
+    element = root.find(tag_name, XML_NAMESPACES)
+    element = _et_to_attributes_dict(element)
+    return element
+
+
+def find_xml_element_text(xml_text: str, tag_name: str):
+    root = et.fromstring(xml_text)
+    el = root.find(tag_name, XML_NAMESPACES)
+    return "".join(el.itertext()).strip() if el is not None else ""

abap_adt_py-0.1.0/src/abap_adt_py.egg-info/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: abap-adt-py
+Version: 0.1.0
+Summary: A Python library for interacting with SAP systems using the ADT (ABAP Development Tools) protocol.
+Author-email: Tim Köhne <20153452+timkoehne@users.noreply.github.com>
+License: MIT License
+        
+        Copyright (c) 2023 timkoehne
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Homepage, https://github.com/timkoehne/abap-adt-py
+Project-URL: Bug Tracker, https://github.com/timkoehne/abap-adt-py/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25
+Requires-Dist: typing-extensions>=4.7.1
+Dynamic: license-file

abap_adt_py-0.1.0/src/abap_adt_py.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+LICENSE
+README.md
+pyproject.toml
+src/abap_adt_py/__init__.py
+src/abap_adt_py/adt_client.py
+src/abap_adt_py/compat_typing.py
+src/abap_adt_py/http_request.py
+src/abap_adt_py/response_parsing.py
+src/abap_adt_py.egg-info/PKG-INFO
+src/abap_adt_py.egg-info/SOURCES.txt
+src/abap_adt_py.egg-info/dependency_links.txt
+src/abap_adt_py.egg-info/requires.txt
+src/abap_adt_py.egg-info/top_level.txt
+src/abap_adt_py/api/__init__.py
+src/abap_adt_py/api/activate.py
+src/abap_adt_py/api/content.py
+src/abap_adt_py/api/create.py
+src/abap_adt_py/api/delete.py
+src/abap_adt_py/api/lock.py
+src/abap_adt_py/api/login.py
+src/abap_adt_py/api/prettyprint.py
+src/abap_adt_py/api/search.py
+src/abap_adt_py/api/unittest.py
+src/abap_adt_py/api/xml_namespaces.py

abap_adt_py-0.1.0/src/abap_adt_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

abap_adt_py-0.1.0/src/abap_adt_py.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests>=2.25
+typing-extensions>=4.7.1

abap_adt_py-0.1.0/src/abap_adt_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+abap_adt_py