dioptic.profileparser 0.2__tar.gz → 0.3.0__tar.gz

{dioptic.profileparser-0.2 → dioptic_profileparser-0.3.0}/.github/workflows/pypi-packages.yml

@@ -11,34 +11,34 @@ jobs:
   build-sdist:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Build sdist package
         run: |
           python -m pip install pip build --upgrade
           python -m build --sdist
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
-          name: packages
+          name: packages-src
           path: "dist/*.tar.gz"
 
   build-win64-wheels:
     runs-on: windows-latest
     strategy:
       matrix:
-        python-version: ["3.9", "3.10", "3.11"]
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: ilammy/msvc-dev-cmd@v1
-      - uses: actions/setup-python@v4
+      - uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
       - name: Build wheel for py${{ matrix.python-version }}
         run: |
           python -m pip install pip build --upgrade
           python -m build --wheel
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
-          name: packages
+          name: packages-win-py${{ matrix.python-version }}
           path: "dist/*.whl"
 
   pypi-publish:
@@ -49,10 +49,11 @@ jobs:
       # IMPORTANT: this permission is mandatory for trusted publishing
       id-token: write
     steps:
-    - uses: actions/download-artifact@v3
+    - uses: actions/download-artifact@v4
       with:
-        name: packages
         path: dist
+        pattern: packages-*
+        merge-multiple: true
     - name: Test PyPI publish
       uses: pypa/gh-action-pypi-publish@release/v1
       with:

dioptic_profileparser-0.3.0/.github/workflows/web-package.yml

@@ -0,0 +1,28 @@
+name: Build WASM/web port
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - v[0-9]+.**
+
+jobs:
+  build-web:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: mymindstorm/setup-emsdk@v14
+        with:
+          version: 3.1.57
+          actions-cache-folder: 'emsdk-cache'
+      - name: Build WASM port
+        run: |
+          cd web
+          mkdir build && cd build
+          emcmake cmake -DCMAKE_BUILD_TYPE="Release" ..
+          cmake --build .
+      - uses: actions/upload-artifact@v4
+        with:
+          name: web
+          path: "web/build/ProfileParserJs.*"

dioptic_profileparser-0.3.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: dioptic.profileparser
+Version: 0.3.0
+Summary: Parser library for ARGOS declarative profiles
+Author-Email: =?utf-8?q?Peter_W=C3=BCrtz?= <pwuertz@gmail.com>
+Classifier: License :: OSI Approved :: MIT License
+Project-URL: Homepage, https://github.com/dioptic/profileparser
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Dioptic declarative profile parser

dioptic_profileparser-0.3.0/cpp/CMakeLists.txt

@@ -0,0 +1,33 @@
+cmake_minimum_required(VERSION 3.16)
+project(libProfileParser CXX)
+
+add_library(libProfileParser STATIC)
+add_library(libProfileParser::libProfileParser ALIAS libProfileParser)
+
+target_include_directories(libProfileParser PUBLIC
+    "${CMAKE_CURRENT_LIST_DIR}/include"
+    )
+
+set_target_properties(libProfileParser PROPERTIES
+    CXX_STANDARD 20
+    CXX_STANDARD_REQUIRED ON
+    POSITION_INDEPENDENT_CODE ON
+    )
+
+if(MSVC)
+    target_compile_options(libProfileParser PUBLIC /W3 /permissive- /Zc:__cplusplus)
+else()
+    target_compile_options(libProfileParser PRIVATE -Wall -Wextra -Wpedantic)
+endif()
+
+target_sources(libProfileParser PRIVATE
+    "include/profileparser.hpp"
+    "include/profileparser/types.hpp"
+    "include/profileparser/utils.hpp"
+    "lineinfo.cpp"
+    "parser.cpp"
+    "parser.hpp"
+    "printers.cpp"
+    "validation.cpp"
+    "peglib.h"  # Use FetchContent?
+    )

dioptic_profileparser-0.3.0/cpp/include/profileparser/types.hpp

@@ -0,0 +1,143 @@
+#pragma once
+
+#include <memory>
+#include <variant>
+#include <vector>
+#include <string>
+#include <tuple>
+#include <functional>
+#include <unordered_map>
+#include <stdexcept>
+
+namespace Profile {
+
+// AST elements
+
+struct SourceInfo {
+    size_t offset;
+    size_t length;
+};
+
+using Boolean = bool;
+using Integer = long;
+using Float = double;
+using String = std::string;
+
+struct ListNode;
+using ListNodePtr = std::shared_ptr<ListNode>;
+struct DictNode;
+using DictNodePtr = std::shared_ptr<DictNode>;
+
+struct NumericExpressionNode;
+using NumericExpressionNodePtr = std::shared_ptr<NumericExpressionNode>;
+struct StringExpressionNode;
+using StringExpressionNodePtr = std::shared_ptr<StringExpressionNode>;
+
+struct ObjectNode;
+using ObjectNodePtr = std::shared_ptr<ObjectNode>;
+struct ReferenceNode;
+using ReferenceNodePtr = std::shared_ptr<ReferenceNode>;
+struct AttributeNode;
+using AttributeNodePtr = std::shared_ptr<AttributeNode>;
+
+struct ReferenceNode {
+    SourceInfo source_info;
+    std::string reference;
+};
+
+using Value = std::variant<ObjectNodePtr, ReferenceNodePtr, NumericExpressionNodePtr, StringExpressionNodePtr, ListNodePtr, DictNodePtr, Boolean, Integer, Float, String>;
+
+struct KeyVal {
+    std::string key;
+    Value value;
+};
+
+struct DocString {
+    SourceInfo source_info;
+    std::vector<std::string> lines; 
+};
+
+struct AttributeNode {
+    SourceInfo source_info;
+    SourceInfo value_source_info;
+    std::string name;
+    Value value;
+};
+
+struct ObjectNode {
+    using Item = std::variant<AttributeNodePtr, ObjectNodePtr>;
+
+    SourceInfo source_info;
+    DocString docstring;
+    std::string classname;
+    std::string id;
+    std::vector<ObjectNodePtr> children;
+    std::vector<AttributeNodePtr> attributes;
+};
+
+struct ListNode {
+    SourceInfo source_info;
+    std::string id;
+    std::vector<Value> items;
+};
+
+struct DictNode {
+    SourceInfo source_info;
+    std::string id;
+    std::vector<KeyVal> items;
+};
+
+struct NumericExpressionNode {
+    SourceInfo source_info;
+    std::string value;
+    std::vector<ReferenceNodePtr> references;
+};
+
+using StringFragment = std::variant<String, ReferenceNodePtr>;
+
+struct StringExpressionNode {
+    SourceInfo source_info;
+    std::vector<StringFragment> fragments;
+};
+
+// Parser API
+
+using CheckRefCallback = std::function<bool(const std::string&)>;
+static inline const CheckRefCallback default_ref_callback = [](const std::string&) { return false; };
+
+struct IdCollection {
+    std::unordered_map<std::string, const ObjectNode*> object_ids;
+    std::unordered_map<std::string, const AttributeNode*> value_ids;
+};
+
+struct ParsedProfile {
+    std::string source;
+    ObjectNodePtr root;
+    IdCollection ids;
+};
+
+struct LineInfo {
+    size_t line;
+    size_t column;
+};
+
+struct LineRange {
+    LineInfo begin;
+    LineInfo end;
+};
+
+struct ErrorLine {
+    LineInfo where;
+    std::string message;
+};
+
+struct ProfileError : public std::runtime_error {
+    ProfileError(std::string message, std::vector<ErrorLine> errors)
+        : std::runtime_error{std::move(message)}
+        , errors{std::move(errors)}
+    {}
+
+    std::vector<ErrorLine> errors;
+};
+
+}

dioptic_profileparser-0.3.0/cpp/include/profileparser/utils.hpp

@@ -0,0 +1,194 @@
+#pragma once
+#include <algorithm>
+#include <sstream>
+#include <profileparser/types.hpp>
+
+namespace Profile {
+
+/**
+ * @brief Locate line & column number of given source info.
+ */
+LineInfo get_line_info(const std::string_view& source, const size_t offset);
+
+/**
+ * @brief Locate line & column number of given source info.
+ */
+inline LineInfo get_line_info(const std::string_view& source, const SourceInfo& info)
+{
+    return get_line_info(source, info.offset);
+}
+
+/**
+ * @brief Locate line & column range of given source info.
+ */
+inline LineRange get_line_range(const std::string_view& source, const SourceInfo& info)
+{
+    return LineRange{
+        .begin=get_line_info(source, info.offset),
+        .end=get_line_info(source, info.offset + info.length),
+    };
+}
+
+/**
+ * @brief Find named attribute field in parsed object node.
+ */
+inline AttributeNodePtr find_attribute(const ObjectNode& obj, const std::string& name)
+{
+    auto it = std::find_if(obj.attributes.begin(), obj.attributes.end(), [&](const auto& a) {
+        return a->name == name;
+    });
+    if (it == obj.attributes.end()) {
+        return nullptr;
+    }
+    return (*it);
+}
+
+/**
+ * @brief visit_values Visit profile value objects.
+ * @param profile Profile object.
+ * @param visitor Value object visitor.
+ */
+inline void visit_values(ObjectNodePtr& profile, auto&& visitor)
+{
+    const auto isValue = [](const ObjectNodePtr& obj) -> bool {
+        return obj->classname == "Value";
+    };
+    for (auto& obj : profile->children) {
+        if (!isValue(obj)) { continue; }
+        visitor(obj);
+    }
+}
+
+/**
+ * @brief visit_values Visit profile value objects.
+ * @param profile Profile object.
+ * @param visitor Value object visitor.
+ */
+inline void visit_values(const ObjectNodePtr& profile, auto&& visitor)
+{
+    const auto isValue = [](const ObjectNodePtr& obj) -> bool {
+        return obj->classname == "Value";
+    };
+    for (const auto& obj : profile->children) {
+        if (!isValue(obj)) { continue; }
+        visitor(obj);
+    }
+}
+
+/**
+ * @brief Template for implementing Profile AST visitors.
+ */
+template<typename VisitorImpl>
+struct Visitor
+{
+    template<typename T>
+    void operator()([[maybe_unused]] const T& v) { }
+
+    template<typename T>
+    void operator()(const std::shared_ptr<T>& v) {
+        return self()(static_cast<const T&>(*v));
+    }
+
+    template<typename... Ts>
+    void operator()(const std::variant<Ts...>& v) {
+        std::visit([&](const auto& v_) { return self()(v_); }, v);
+    }
+
+    void operator()(const ListNode& r) {
+        for(const auto& v: r.items) { self()(v); };
+    }
+
+    void operator()(const DictNode& r) {
+        for(const auto& v: r.items) { self()(v); };
+    }
+
+    void operator()(const ObjectNode& obj) {
+        for (const ObjectNodePtr& child: obj.children) { self()(child); }
+        for (const AttributeNodePtr& attr: obj.attributes) { self()(attr->value); }
+    }
+
+private:
+    inline VisitorImpl& self() { return static_cast<VisitorImpl&>(*this); }
+};
+
+/**
+ * @brief Visitor for collecting Objects and Values with an identifier
+ */
+struct IdCollector : protected Visitor<IdCollector>
+{
+    IdCollection& collection;
+    std::string_view source;
+    std::vector<ErrorLine>& errors;
+
+    IdCollector(IdCollection& collection, std::string_view source, std::vector<ErrorLine>& errors)
+        : Visitor<IdCollector>{}
+        , collection{collection}
+        , source{source}
+        , errors{errors}
+    { }
+
+    void operator()(const ObjectNode& obj)
+    {
+        // Object with id, check for duplicates
+        if (!obj.id.empty()) {
+            if (!collection.object_ids.emplace(obj.id, &obj).second) {
+                add_error("Object id '" + obj.id + "' was declared multiple times", obj.source_info);
+            }
+        }
+        // If object is 'Value', store reference to value attribute
+        if (obj.classname == "Value") {
+            if (obj.id.empty()) {
+                add_error("Value object is missing id", obj.source_info);
+            }
+            auto value_attr = find_attribute(obj, "value");
+            if (value_attr == nullptr) {
+                add_error("Value object '" + obj.id + "' is missing 'value' attribute", obj.source_info);
+            } else
+                collection.value_ids.emplace(obj.id, &(*value_attr));
+        }
+        // Continue search for objects in children and attribute list
+        Visitor<IdCollector>::operator()(obj);
+    }
+
+    inline void add_error(auto&& message, SourceInfo where)
+    {
+        errors.emplace_back(ErrorLine{
+            .where=get_line_info(source, where),
+            .message=std::forward<decltype(message)>(message),
+        });
+    }
+
+protected:
+    friend struct Visitor<IdCollector>;
+    using Visitor::operator();
+};
+
+
+inline ProfileError format_error(const std::string_view& message, std::vector<ErrorLine>&& errors)
+{
+    std::stringstream ss;
+    ss << std::move(message);
+    for (auto& line : errors) {
+        ss << '\n' << line.where.column << ':' << line.where.column << ' ' << line.message;
+    }
+    return ProfileError { ss.str(), std::move(errors) };
+}
+
+/**
+ * @brief Create ID collection from parsed profile.
+ * 
+ * @throws ProfileError Thrown if profile contains invalid ID information.
+ */
+inline IdCollection collect_ids(const ObjectNodePtr& obj, std::string_view source)
+{
+    IdCollection collection;
+    std::vector<ErrorLine> errors;
+    IdCollector collect(collection, source, errors);
+    collect(*obj);
+    if (!errors.empty()) {
+        throw format_error("Error assembling object ID information", std::move(errors));
+    }
+    return collection;
+}
+
+}  // namespace Profile

dioptic_profileparser-0.3.0/cpp/include/profileparser.hpp

@@ -0,0 +1,58 @@
+#pragma once
+#include <profileparser/types.hpp>
+
+namespace Profile {
+
+/**
+ * @brief Parse profile from source string.
+ * 
+ * @param source Profile source.
+ * @throws ProfileError Thrown if parsing profile from source failed.
+ * @return Parsed profile.
+ */
+ParsedProfile parse(std::string source);
+
+/**
+ * @brief Get source information from node source reference
+ * @param profile Parsed profile.
+ * @param info Source reference from node.
+ * @return Corresponding line/column source range.
+ */
+LineRange get_source_range(const ParsedProfile& profile, SourceInfo info);
+
+/**
+ * @brief Serialize profile object to profile source.
+ * @param profile Parsed profile.
+ * @return Profile source serialization.
+ */
+std::string to_profile_source(const ParsedProfile& profile);
+
+/**
+ * @brief Re-emit profile source with given value substitutions.
+ * 
+ * @param profile Parsed profile.
+ * @param values Value substitutions.
+ * @return Updated profile source.
+ */
+std::string to_updated_source(const ParsedProfile& profile, const std::unordered_map<std::string, Value>& values);
+std::string to_updated_source(const ParsedProfile& profile, const std::unordered_map<const AttributeNode*, Value>& values);
+
+/**
+ * @brief Serialize profile object to JSON representation.
+ * @param profile Parsed profile.
+ * @param eval_expressions If true, serialize with expressions evaluated to constants.
+ * @return JSON serialization.
+ */
+std::string to_json_ast(const ParsedProfile& profile, const bool eval_expressions);
+
+/**
+ * @brief Validate profile for use in `argosprocess`.
+ * 
+ * @param profile Parsed profile.
+ * @param is_allowed_ref Callback for validating external references.
+ * 
+ * @throws ProfileError Thrown if semantic validation failed.
+ */
+void validate_profile(const ParsedProfile& profile, const CheckRefCallback& is_allowed_ref = default_ref_callback);
+
+}  // namespace Profile

dioptic_profileparser-0.3.0/cpp/lineinfo.cpp

@@ -0,0 +1,21 @@
+#include <profileparser.hpp>
+#include <profileparser/utils.hpp>
+#include "peglib.h"
+
+namespace Profile
+{
+
+LineInfo get_line_info(const std::string_view& source, const size_t offset)
+{
+    // TODO: `peg::line_info` correctly counts unicode characters, but lacks line-cache like `vs.line_info`.
+    const auto* sourceStart = source.data();
+    auto [line, column] = peg::line_info(sourceStart, sourceStart + offset);
+    return LineInfo{ .line=line, .column=column };
+}
+
+LineRange get_source_range(const ParsedProfile& profile, SourceInfo info)
+{
+    return get_line_range(profile.source, info);
+}
+
+} // namespace Profile