docstring-generator-ext 2.0.11__tar.gz → 2.0.12__tar.gz

{docstring_generator_ext-2.0.11 → docstring_generator_ext-2.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docstring_generator_ext
-Version: 2.0.11
+Version: 2.0.12
 Summary: Generate Docstrings with type-hint information.
 Author-email: FelixTheC <fberndt87@gmail.com>
 Classifier: Environment :: Console

{docstring_generator_ext-2.0.11 → docstring_generator_ext-2.0.12}/docstring_generator_ext.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docstring_generator_ext
-Version: 2.0.11
+Version: 2.0.12
 Summary: Generate Docstrings with type-hint information.
 Author-email: FelixTheC <fberndt87@gmail.com>
 Classifier: Environment :: Console

{docstring_generator_ext-2.0.11 → docstring_generator_ext-2.0.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "docstring_generator_ext"
-version = "2.0.11"
+version = "2.0.12"
 description = "Generate Docstrings with type-hint information."
 authors = [
     { name = "FelixTheC", email = "fberndt87@gmail.com" },

{docstring_generator_ext-2.0.11 → docstring_generator_ext-2.0.12}/src/FunctionFormat.cpp

@@ -23,38 +23,7 @@ ParameterKind from_str(const std::string &kind) {
 }
 
 std::ostream &operator<<(std::ostream &out, ParameterKind const &obj) noexcept {
-    switch (obj) {
-        case ParameterKind::ARG:
-            return out << "Argument";
-        case ParameterKind::POS_ONLY:
-            return out << "Positional only argument";
-        case ParameterKind::KW_ONLY:
-            return out << "Keyword only argument";
-        case ParameterKind::VARIADIC_ARG:
-            return out << "Variadic arguments";
-        case ParameterKind::KEYWORD_ARG:
-            return out << "Keyword arguments";
-    }
-
-    return out;
-}
-
-std::string parameter_kind::to_str(const ParameterKind &kind) {
-    std::string name = "UNKNOWN";
-    switch (kind) {
-        case ParameterKind::ARG: name = "Argument";
-            break;
-        case ParameterKind::POS_ONLY: name = "Positional only argument";
-            break;
-        case ParameterKind::KW_ONLY: name = "Keyword only argument";
-            break;
-        case ParameterKind::VARIADIC_ARG: name = "Variadic arguments";
-            break;
-        case ParameterKind::KEYWORD_ARG: name = "Keyword arguments";
-            break;
-    }
-
-    return name;
+    return out << parameter_kind::to_str(obj);
 }
 
 void FunctionParameter::update_description(const std::string &descr, const DocstringFormatStyle &formatStyle) noexcept {
@@ -176,6 +145,10 @@ void FunctionInfo::update_descriptions(const DocstringFormatStyle &formatStyle)
     }
 }
 
+bool FunctionInfo::summary_only() const noexcept {
+    return args.empty() && returns.type.empty() && exceptions.empty();
+}
+
 void FunctionDocstring::detect_format_style() noexcept {
     bool could_be_numpy = false;
     bool could_be_google = false;

{docstring_generator_ext-2.0.11 → docstring_generator_ext-2.0.12}/src/FunctionFormat.hpp

@@ -41,27 +41,22 @@ ParameterKind from_str(const std::string &kind);
 std::ostream &operator<<(std::ostream &out, ParameterKind const &obj) noexcept;
 
 namespace parameter_kind{
-    std::string to_str(const ParameterKind &kind);
+    inline std::string to_str(const ParameterKind &kind) {
+        switch (kind) {
+            case ParameterKind::ARG:          return "Argument";
+            case ParameterKind::POS_ONLY:     return "Positional only argument";
+            case ParameterKind::KW_ONLY:      return "Keyword only argument";
+            case ParameterKind::VARIADIC_ARG: return "Variadic arguments";
+            case ParameterKind::KEYWORD_ARG:  return "Keyword arguments";
+        }
+        return "UNKNOWN";
+    }
 }
 
 template<>
-struct std::formatter<ParameterKind> : std::formatter<std::string_view> {
-    // Format the enum by mapping it to a string_view
-    auto format(ParameterKind kind, std::format_context &ctx) const {
-        std::string_view name = "UNKNOWN";
-        switch (kind) {
-            case ParameterKind::ARG: name = "Argument";
-                break;
-            case ParameterKind::POS_ONLY: name = "Positional only argument";
-                break;
-            case ParameterKind::KW_ONLY: name = "Keyword only argument";
-                break;
-            case ParameterKind::VARIADIC_ARG: name = "Variadic arguments";
-                break;
-            case ParameterKind::KEYWORD_ARG: name = "Keyword arguments";
-                break;
-        }
-        return std::formatter<std::string_view>::format(name, ctx);
+struct std::formatter<ParameterKind> : std::formatter<std::string> {
+    auto format(const ParameterKind &kind, std::format_context &ctx) const {
+        return std::formatter<std::string>::format(parameter_kind::to_str(kind), ctx);
     }
 };
 
@@ -113,6 +108,7 @@ struct FunctionInfo {
 
     [[nodiscard]] int get_file_write_position() const noexcept;
     void update_descriptions(const DocstringFormatStyle &formatStyle) noexcept;
+    [[nodiscard]] bool summary_only() const noexcept;
 };
 
 #endif //DOCSTRING_GENERATOR_EXT_FUNCTIONFORMAT_HPP

{docstring_generator_ext-2.0.11 → docstring_generator_ext-2.0.12}/src/GoogleDocstring.cpp

@@ -1,17 +1,16 @@
 #include "GoogleDocstring.hpp"
-
-#include <format>
-
 #include "parser.hpp"
 
 void GoogleDocstring::check_current_docstring() noexcept {
     auto current_py_tab = get_tabs();
     auto google_args_begin = functionInfo.docstring.docstring.find("Args:");
 
-    if (google_args_begin < std::string::npos) {
+    if (google_args_begin != std::string::npos) {
+        const auto strip_len = current_py_tab.size() + 1;
+        const auto trim_pos = google_args_begin > strip_len ? google_args_begin - strip_len : 0;
         functionInfo.docstring.docstring = functionInfo.docstring.docstring.substr(
             0,
-            google_args_begin - (current_py_tab.size() + 1)
+            trim_pos
         );
         functionInfo.docstring.end_line = functionInfo.docstring.start_line + google_args_begin;
     }
@@ -20,11 +19,11 @@ void GoogleDocstring::check_current_docstring() noexcept {
 std::string GoogleDocstring::cleanArgsDescription(const std::string &arg, const std::string &description) noexcept {
     std::string res = std::string {description};
 
-    if (const auto startPos = description.find("Args:\n"); startPos < std::string::npos) {
+    if (const auto startPos = description.find("Args:\n"); startPos != std::string::npos) {
         res = res.substr(startPos, res.size() - startPos);
     }
 
-    if (const auto startPos = res.find(arg); startPos < std::string::npos) {
+    if (const auto startPos = res.find(arg); startPos != std::string::npos) {
         const auto pos = startPos + arg.size() + 1;
         if (pos > res.size())
             return res;
@@ -34,20 +33,25 @@ std::string GoogleDocstring::cleanArgsDescription(const std::string &arg, const
     return res;
 }
 
-std::string GoogleDocstring::docstringArgs() noexcept {
-    auto current_py_tab = get_tabs();
-
-    std::string result;
-    result.reserve(256); // rough upfront guess for typical arg count
-
-    if (!functionInfo.docstring.docstring.empty()) {
-         result += functionInfo.docstring.docstring;
-         result += "\n";
+std::string GoogleDocstring::docstringSummary() noexcept {
+    std::string res = functionInfo.docstring.docstring;
+    if (res.empty())
+        return res;
+    if (!functionInfo.summary_only()) {
+        if (!res.ends_with('\n'))
+            res += '\n';
     }
+    return res;
+}
 
+std::string GoogleDocstring::docstringArgs() noexcept {
     if (functionInfo.args.empty())
         return "";
 
+    auto current_py_tab = get_tabs();
+
+    std::string result;
+
     if (PY_TAB != current_py_tab) {
         result += current_py_tab;
         current_py_tab += PY_TAB;
@@ -55,49 +59,45 @@ std::string GoogleDocstring::docstringArgs() noexcept {
         result += PY_TAB;
         current_py_tab = PY_TAB + PY_TAB;
     }
-
-    int idx = 0;
-    const int last_idx = functionInfo.args.size();
     result += "Args:\n";
     for (const auto &val : functionInfo.args) {
-        ++idx;
-        result += current_py_tab;
-        result += val.name;
-        if (!val.type.empty()) {
-            result += " (";
+        result += std::format("{}{} (", current_py_tab, val.name);
+        if (val.type.empty())
+            result += "Any";
+        else
             result += val.type;
-            if (!val.default_value.empty()) {
-                result += ", optional";
-            }
-            result += ")";
+        if (!val.default_value.empty()) {
+            result += ", optional";
         }
+        result += "): ";
+
+        if (val.kind != ParameterKind::ARG) {
+            result += std::format("{}. ", parameter_kind::to_str(val.kind));
+        }
+
         if (!val.description.empty()) {
-            result += ": ";
-            result += cleanArgsDescription(val.name, val.description);
+            result += std::format("{}", cleanArgsDescription(val.name, val.description));
+            if (!result.ends_with('.'))
+                result += '.';
+            result += ' ';
         }
+
         if (!val.default_value.empty()) {
-            result += " (default is ";
-            result += val.default_value;
-            result += ")";
+            result += std::format("Defaults to {}.", val.default_value);
         }
 
-        if (idx < last_idx) {
-            result += "\n";
-        }
+        result += '\n';
     }
     return result;
 }
 
 std::string GoogleDocstring::docstringReturn() noexcept {
     std::string result;
-    result.reserve(256); // rough upfront guess for typical arg count
 
     auto current_py_tab = get_tabs();
 
     if (!functionInfo.returns.description.empty() || !functionInfo.returns.type.empty()) {
-        result += "\n";
         result += current_py_tab;
-
         result += "Returns:\n";
         current_py_tab += PY_TAB;
         result += current_py_tab;
@@ -108,6 +108,7 @@ std::string GoogleDocstring::docstringReturn() noexcept {
         if (!functionInfo.returns.description.empty()) {
             result += functionInfo.returns.description;
         }
+        result += '\n';
     } else {
         result = "";
     }
@@ -120,22 +121,16 @@ std::string GoogleDocstring::docstringExceptions() noexcept {
         return "\n";
 
     std::string result;
-    result.reserve(256); // rough upfront guess for typical arg count
     auto current_py_tab = get_tabs();
 
-    result += "\n";
     result += current_py_tab;
 
     current_py_tab += PY_TAB;
 
     result += "Raises:\n";
-    result += current_py_tab;
 
-    int idx = 0;
-    const int last_exception = functionInfo.exceptions.size();
     for (const auto &[name, description] : functionInfo.exceptions) {
-        ++idx;
-
+        result += current_py_tab;
         if (!name.empty()) {
             result += std::format("{}: ", name);
         }
@@ -143,10 +138,7 @@ std::string GoogleDocstring::docstringExceptions() noexcept {
             result += description;
         }
 
-        result += "\n";
-        if (idx < last_exception) {
-             result += current_py_tab;
-        }
+        result += '\n';
     }
 
     return result;

{docstring_generator_ext-2.0.11 → docstring_generator_ext-2.0.12}/src/GoogleDocstring.hpp

@@ -5,6 +5,7 @@
 
 struct GoogleDocstring : DocstringFormat {
     void check_current_docstring() noexcept override;
+    std::string docstringSummary() noexcept override;
     std::string docstringArgs() noexcept override;
     std::string docstringReturn() noexcept override;
     std::string docstringExceptions() noexcept override;

{docstring_generator_ext-2.0.11 → docstring_generator_ext-2.0.12}/src/IDocstringFormat.cpp

@@ -1,6 +1,12 @@
 #include "IDocstringFormat.hpp"
 #include "parser.hpp"
 
+bool onlyQuotesAndWhitespace(const std::string& s) {
+    return std::ranges::all_of(s, [](char c) {
+        return c == '"' || std::isspace(static_cast<unsigned char>(c));
+    });
+}
+
 [[ nodiscard ]] std::string DocstringFormat::docstring() noexcept {
     std::string result;
     result.reserve(1024); // rough upfront guess for typical arg count
@@ -8,23 +14,28 @@
 
     result += current_pytab;
     result += R"(""")";
-    if (functionInfo.docstring.docstring.empty()) {
-        result += "\n";
+    if (const auto summaryTxt = docstringSummary(); !summaryTxt.empty()) {
+        result += summaryTxt;
+    } else {
+        result += '\n';
     }
+
     if (const auto argTxt = docstringArgs(); !argTxt.empty()) {
         result += argTxt;
     }
-    if (const auto returnTxt = docstringReturn(); !returnTxt.empty())
-        result += docstringReturn();
-    if (const auto exceptionTxt = docstringExceptions(); !exceptionTxt.empty())
-        result += docstringExceptions();
+    if (const auto returnTxt = docstringReturn(); !returnTxt.empty()) {
+        result += returnTxt;
+    }
+    if (const auto exceptionTxt = docstringExceptions(); !exceptionTxt.empty() && exceptionTxt != "\n") {
+        result += exceptionTxt;
+    }
 
-    result += current_pytab;
+    if (result.ends_with('\n'))
+        result += current_pytab;
     result += R"(""")";
-    if (functionInfo.docstring.docstring.empty()) {
-        result += "\n";
-    }
 
+    if (onlyQuotesAndWhitespace(result))
+        return "";
     return result;
 }
 

{docstring_generator_ext-2.0.11 → docstring_generator_ext-2.0.12}/src/IDocstringFormat.hpp

@@ -8,6 +8,8 @@
 struct DocstringFormat {
     FunctionInfo functionInfo;
 
+    virtual std::string docstringSummary() noexcept = 0;
+
     virtual std::string docstringArgs() noexcept = 0;
 
     virtual std::string docstringReturn() noexcept = 0;

docstring_generator_ext-2.0.12/src/NumpyDocstring.cpp

@@ -0,0 +1,144 @@
+#include "NumpyDocstring.hpp"
+
+#include "parser.hpp"
+
+void NumpyDocstring::check_current_docstring() noexcept {
+    const auto current_py_tab = get_tabs();
+    const auto numpy_args_begin = functionInfo.docstring.docstring.find("Parameters");
+
+    if (numpy_args_begin != std::string::npos) {
+        const auto strip_len = current_py_tab.size() + 1;
+        const auto trim_pos = numpy_args_begin > strip_len ? numpy_args_begin - strip_len : 0;
+        functionInfo.docstring.docstring = functionInfo.docstring.docstring.substr(
+            0,
+            trim_pos
+        );
+        functionInfo.docstring.end_line = functionInfo.docstring.start_line + numpy_args_begin;
+    }
+}
+
+std::string NumpyDocstring::docstringSummary() noexcept {
+    std::string res = functionInfo.docstring.docstring;
+    if (res.empty())
+        return res;
+    if (!functionInfo.summary_only()) {
+        res += '\n';
+    }
+    return res;
+}
+
+std::string NumpyDocstring::docstringArgs() noexcept {
+    std::string docstream;
+    const auto current_py_tab = get_tabs();
+
+    if (functionInfo.args.empty()) {
+        return docstream;
+    }
+
+    docstream.reserve(1024);
+
+    docstream += std::format("{}Parameters\n", current_py_tab);
+    docstream += std::format("{}----------\n", current_py_tab);
+    std::ranges::for_each(
+        functionInfo.args,
+        [&docstream, &current_py_tab](const FunctionParameter &val) {
+            std::string result;
+            result.reserve(256);
+
+            if (val.name.empty())
+                result += std::format("{}PLACEHOLDER", current_py_tab);
+            else
+                result += std::format("{}{}", current_py_tab,val.name);
+
+            result += " :";
+
+            if (!val.type.empty()) {
+                result += std::format(" {}", val.type);
+
+                if (!val.default_value.empty()) {
+                    result += ", optional";
+                }
+            } else {
+                result += " Any";
+            }
+
+            if (val.kind != ParameterKind::ARG) {
+                result += '\n';
+                result += std::format("{}{}{}", current_py_tab, PY_TAB, parameter_kind::to_str(val.kind));
+            }
+
+            if (!val.description.empty()) {
+                result += '\n';
+                result += std::format("{}{}{}", current_py_tab, PY_TAB, remove_whitespace(val.description));
+                if (!result.ends_with('.'))
+                    result += '.';
+            }
+
+            if (!val.default_value.empty()) {
+                std::string offset = " ";
+                if (val.description.empty()) {
+                    result += '\n';
+                    offset =  std::format("{}{}", current_py_tab, PY_TAB);
+                }
+
+                 result += std::format("{}default: {}", offset, val.default_value);
+             }
+
+            result = remove_trailing_whitespace(result);
+
+            docstream += std::format("{}\n", result);
+        }
+    );
+    docstream += '\n';
+    return docstream;
+}
+
+std::string NumpyDocstring::docstringReturn() noexcept {
+    std::string result;
+    const auto current_py_tab = get_tabs();
+    if (functionInfo.returns.type.empty() and functionInfo.returns.description.empty())
+        return "";
+
+    result.reserve(256);
+
+    if (!functionInfo.returns.type.empty()) {
+        result += std::format("{}Returns\n", current_py_tab);
+        result += std::format("{}-------\n", current_py_tab);
+
+        result += std::format("{}{}", current_py_tab, functionInfo.returns.type);
+    }
+
+    if (!functionInfo.returns.description.empty()) {
+        result += '\n';
+        result += std::format("{}{}{}", current_py_tab, PY_TAB, functionInfo.returns.description);
+    }
+
+    result += '\n';
+    result += '\n';
+    return result;
+}
+
+std::string NumpyDocstring::docstringExceptions() noexcept {
+    if (functionInfo.exceptions.empty())
+        return "";
+
+    std::string result;
+    result.reserve(256);
+    const auto current_py_tab = get_tabs();
+
+    result += std::format("{}Raises\n", current_py_tab);
+    result += std::format("{}------\n", current_py_tab);
+
+    for (const auto &[name, description]: functionInfo.exceptions) {
+        if (!name.empty()) {
+            result += std::format("{}{}", current_py_tab, name);
+            result += '\n';
+        }
+        if (!description.empty()) {
+            result += std::format("{}{}{}", current_py_tab, PY_TAB, description);
+        }
+        result += '\n';
+    }
+
+    return result;
+}

{docstring_generator_ext-2.0.11 → docstring_generator_ext-2.0.12}/src/NumpyDocstring.hpp

@@ -4,6 +4,7 @@
 
 struct NumpyDocstring : DocstringFormat {
     void check_current_docstring() noexcept override;
+    std::string docstringSummary() noexcept override;
     std::string docstringArgs() noexcept override;
     std::string docstringReturn() noexcept override;
     std::string docstringExceptions() noexcept override;

{docstring_generator_ext-2.0.11 → docstring_generator_ext-2.0.12}/src/ReStructuredDocstring.cpp

@@ -7,25 +7,33 @@ void reStructuredDocstring::check_current_docstring() noexcept {
     const auto current_py_tab = get_tabs();
     const auto rest_args_begin = functionInfo.docstring.docstring.find(":param");
 
-    if (rest_args_begin < std::string::npos) {
+    if (rest_args_begin != std::string::npos) {
+        const auto strip_len = current_py_tab.size() + 1;
+        const auto trim_pos = rest_args_begin > strip_len ? rest_args_begin - strip_len : 0;
         functionInfo.docstring.docstring = functionInfo.docstring.docstring.substr(
             0,
-            rest_args_begin - (current_py_tab.size() + 1)
+            trim_pos
         );
         functionInfo.docstring.end_line = functionInfo.docstring.start_line + rest_args_begin;
     }
 }
 
+std::string reStructuredDocstring::docstringSummary() noexcept {
+    std::string res = functionInfo.docstring.docstring;
+    if (res.empty())
+        return res;
+    if (!functionInfo.summary_only()) {
+        if (!res.ends_with('\n'))
+            res += '\n';
+    }
+    return res;
+}
+
 std::string reStructuredDocstring::docstringArgs() noexcept {
     std::stringstream docstream;
 
     const auto current_py_tab = get_tabs();
 
-    if (!functionInfo.docstring.docstring.empty()) {
-        docstream << functionInfo.docstring.docstring;
-        docstream << "\n";
-    }
-
     std::ranges::for_each(
         functionInfo.args,
         [&docstream, &current_py_tab](const FunctionParameter &val) {

{docstring_generator_ext-2.0.11 → docstring_generator_ext-2.0.12}/src/ReStructuredDocstring.hpp

@@ -10,6 +10,8 @@
 struct reStructuredDocstring : DocstringFormat {
     void check_current_docstring() noexcept override;
 
+    std::string docstringSummary() noexcept override;
+
     std::string docstringArgs() noexcept override;
 
     std::string docstringReturn() noexcept override;

{docstring_generator_ext-2.0.11 → docstring_generator_ext-2.0.12}/src/docstringFormat.cpp

@@ -146,6 +146,27 @@ std::map<std::string, int> check_docstrings(std::string &file_path, const bool &
             };
 }
 
+[[nodiscard]] std::string create_docstring_from_function_info(const FunctionInfo &function_info, const DocstringFormatStyle &formatStyle) noexcept {
+    std::unique_ptr<DocstringFormat> docstring_format;
+
+    switch (formatStyle) {
+        case DocstringFormatStyle::reST:
+            docstring_format = std::make_unique<reStructuredDocstring>();
+            break;
+        case DocstringFormatStyle::GOOGLE:
+            docstring_format = std::make_unique<GoogleDocstring>();
+            break;
+        case DocstringFormatStyle::NUMPY:
+            docstring_format = std::make_unique<NumpyDocstring>();
+            break;
+    }
+
+    docstring_format->functionInfo = function_info;
+    docstring_format->check_current_docstring();
+
+    return docstring_format->docstring();
+}
+
 [[nodiscard]] WriteResult write_to_file_position(
     std::vector<FunctionInfo> &&infos,
     const std::string &file_path,
@@ -191,24 +212,11 @@ std::map<std::string, int> check_docstrings(std::string &file_path, const bool &
 
         lines.erase(lines.begin() + start_pos, lines.begin() + end_pos);
 
-        std::unique_ptr<DocstringFormat> docstring_format;
-
-        switch (formatStyle) {
-            case DocstringFormatStyle::reST:
-                docstring_format = std::make_unique<reStructuredDocstring>();
-                break;
-            case DocstringFormatStyle::GOOGLE:
-                docstring_format = std::make_unique<GoogleDocstring>();
-                break;
-            case DocstringFormatStyle::NUMPY:
-                docstring_format = std::make_unique<NumpyDocstring>();
-                break;
-        }
-
-        docstring_format->functionInfo = val;
-        docstring_format->check_current_docstring();
+        const auto txt = create_docstring_from_function_info(val, formatStyle);
+        if (txt.empty() || txt == "\n")
+            continue;
 
-        lines.insert(lines.begin() + start_pos, docstring_format->docstring());
+        lines.insert(lines.begin() + start_pos, txt);
     }
 
     std::ofstream out_file(file_path);

{docstring_generator_ext-2.0.11 → docstring_generator_ext-2.0.12}/src/docstringFormat.hpp

@@ -20,6 +20,8 @@ void get_docstring_arg_descr(FunctionInfo &functionInfo) noexcept;
 
 void parse_file(const std::string &file_path, const DocstringFormatStyle &formatStyle, const bool &allow_overwrite = false, const bool &ignore_magic = false);
 
+[[nodiscard]] std::string create_docstring_from_function_info(const FunctionInfo &function_info, const DocstringFormatStyle &formatStyle) noexcept;
+
 /*
  * {
  *    'num_functions_checked': 0,

{docstring_generator_ext-2.0.11 → docstring_generator_ext-2.0.12}/src/parser.cpp

@@ -55,9 +55,17 @@ std::string parse_ast_name(const py::object &obj, py::module &) noexcept {
 }
 
 std::string parse_ast_subscript(const py::object &obj, py::module &ast_module) noexcept {
-    auto value = py::getattr(obj, "value");
-    auto slice = py::getattr(obj, "slice");
-    return parse_ast_obj(value, ast_module) + "[" + parse_ast_obj(slice, ast_module) + "]";
+    const auto value = py::getattr(obj, "value");
+    const auto slice = py::getattr(obj, "slice");
+    const std::string module_name = parse_ast_obj(value, ast_module);
+    const std::string inner_obj = parse_ast_obj(slice, ast_module);
+    if (module_name == "Annotated" || module_name == "Union") {
+        return inner_obj;
+    }
+    if (module_name == "Optional")
+        return std::format( "{} | None", inner_obj);
+    const std::string res = std::format( "{}[{}]",module_name, inner_obj);
+    return res;
 }
 
 std::string parse_ast_attribute(const py::object &obj, py::module &ast_module) noexcept {
@@ -79,21 +87,22 @@ std::string parse_ast_tuple_list(const py::object &obj, py::module &ast_module)
 
     for (py::handle item: elts) {
         auto py_obj = py::reinterpret_borrow<py::object>(item);
-        result += parse_ast_obj(py_obj, ast_module) + ", ";
+        result += parse_ast_obj(py_obj, ast_module) + " | ";
     }
 
-    return result.substr(0, result.size() - 2);
+    std::string res = result.substr(0, result.size() - 3);
+    if (res.ends_with(" | "))
+        res = res.substr(0, res.size() - 3);
+    return res;
 }
 
 std::string parse_ast_binop(const py::object &obj, py::module &ast_module) noexcept {
     auto left = py::getattr(obj, "left");
     auto right = py::getattr(obj, "right");
 
-    std::string result = "Union["
-                         + parse_ast_obj(left, ast_module)
-                         + ", "
-                         + parse_ast_obj(right, ast_module)
-                         + "]";
+    std::string result = std::format("{} | {}",
+        parse_ast_obj(left, ast_module),
+        parse_ast_obj(right, ast_module));
     return result;
 }
 

docstring_generator_ext-2.0.11/src/NumpyDocstring.cpp

@@ -1,122 +0,0 @@
-#include "NumpyDocstring.hpp"
-
-#include "parser.hpp"
-
-void NumpyDocstring::check_current_docstring() noexcept {
-    const auto current_py_tab = get_tabs();
-    const auto numpy_args_begin = functionInfo.docstring.docstring.find("Parameters");
-
-    if (numpy_args_begin < std::string::npos) {
-        functionInfo.docstring.docstring = functionInfo.docstring.docstring.substr(
-            0,
-            numpy_args_begin - (current_py_tab.size() + 1)
-        );
-        functionInfo.docstring.end_line = functionInfo.docstring.start_line + numpy_args_begin;
-    }
-}
-
-std::string NumpyDocstring::docstringArgs() noexcept {
-    std::stringstream docstream;
-    const auto current_py_tab = get_tabs();
-
-    if (!functionInfo.docstring.docstring.empty()) {
-        docstream << functionInfo.docstring.docstring;
-        docstream << "\n";
-    }
-
-    if (functionInfo.args.empty())
-        return "";
-
-    docstream << current_py_tab << "Parameters\n";
-    docstream << current_py_tab << "----------\n";
-    std::ranges::for_each(
-        functionInfo.args,
-        [&docstream, &current_py_tab](const FunctionParameter &val) {
-            std::stringstream sstream;
-
-            if (val.name.empty())
-                sstream << current_py_tab << "PLACEHOLDER";
-            else
-                sstream << current_py_tab << val.name;
-
-            sstream << " :";
-
-            if (!val.type.empty()) {
-                sstream << " " << val.type;
-
-                if (!val.default_value.empty()) {
-                    sstream << ", optional";
-                }
-            }
-
-            if (!val.default_value.empty()) {
-                if (!val.type.empty()) {
-                    sstream << ", ";
-                }
-                sstream << "default: " << val.default_value;
-            }
-
-            sstream << " [" << val.kind << "]";
-
-            if (!val.description.empty()) {
-                sstream << "\n";
-                sstream << current_py_tab << PY_TAB << remove_whitespace(val.description);
-            }
-
-            auto docstring = sstream.str();
-            docstring = remove_trailing_whitespace(docstring);
-
-            docstream << docstring << "\n";
-        }
-    );
-
-    return docstream.str();
-}
-
-std::string NumpyDocstring::docstringReturn() noexcept {
-    std::stringstream sstream;
-    const auto current_py_tab = get_tabs();
-
-    if (!functionInfo.returns.type.empty()) {
-        sstream << "\n";
-        sstream << current_py_tab << "Returns\n";
-        sstream << current_py_tab << "-------\n";
-
-        sstream << current_py_tab << functionInfo.returns.type;
-    }
-
-    if (!functionInfo.returns.description.empty()) {
-        sstream << "\n";
-        sstream << current_py_tab << PY_TAB << functionInfo.returns.description;
-    }
-
-    if (!functionInfo.returns.type.empty() || !functionInfo.returns.description.empty())
-        sstream << "\n";
-
-    return sstream.str();
-}
-
-std::string NumpyDocstring::docstringExceptions() noexcept {
-    if (functionInfo.exceptions.empty())
-        return "";
-
-    std::stringstream sstream;
-    const auto current_py_tab = get_tabs();
-
-    sstream << "\n";
-    sstream << current_py_tab << "Raises\n";
-    sstream << current_py_tab << "-------\n";
-
-    for (const auto &[name, description]: functionInfo.exceptions) {
-        if (!name.empty()) {
-            sstream << current_py_tab << name;
-            sstream << "\n";
-        }
-        if (!description.empty()) {
-            sstream << current_py_tab << PY_TAB << description;
-        }
-        sstream << "\n";
-    }
-
-    return sstream.str();
-}