Refactor imports

.generator/src/generator/formatter.py

@@ -307,7 +307,7 @@ def format_parameters(data, spec, replace_values=None, has_body=False, **kwargs)
     if has_body and body_is_required:
         parameters += "body, "
     if has_optional or body_is_required is False:
-        imports.add(f"datadog_api_client::datadog{kwargs.get('version', '')}::api::api_{kwargs.get('api')}::{spec['operationId']}OptionalParams")
+        imports.add(f"datadog_api_client::datadog{kwargs.get('version', '')}::api_{kwargs.get('api')}::{spec['operationId']}OptionalParams")
         parameters += f"{spec['operationId']}OptionalParams::default()"
         if has_body and not body_is_required:
             parameters += ".body(body)"

.generator/src/generator/templates/api.j2

@@ -1,7 +1,6 @@
 {% include "partial_header.j2" %}
-use reqwest;
 use serde::{Serialize, Deserialize};
-use crate::datadog::*;
+use crate::datadog;
 use reqwest::header::{HeaderMap, HeaderValue};
 {%- for _, _, operation in operations if "x-pagination" in operation %}
 {%- if loop.first %}
@@ -84,21 +83,21 @@ pub enum {{operation.operationId}}Error {
 
 #[derive(Debug, Clone)]
 pub struct {{ structName }} {
-    config: configuration::Configuration,
+    config: datadog::Configuration,
     client: reqwest_middleware::ClientWithMiddleware,
 }
 
 impl Default for {{ structName }} {
     fn default() -> Self {
-        Self::with_config(configuration::Configuration::default())
+        Self::with_config(datadog::Configuration::default())
     }
 }
 
 impl {{ structName }} {
     pub fn new() -> Self {
         Self::default()
     }
-    pub fn with_config(config: configuration::Configuration) -> Self {
+    pub fn with_config(config: datadog::Configuration) -> Self {
          let mut reqwest_client_builder = reqwest::Client::builder();
 
         if let Some(proxy_url) = &config.proxy_url {
@@ -140,7 +139,7 @@ impl {{ structName }} {
         Self { config, client }
     }
 
-    pub fn with_client_and_config(config: configuration::Configuration, client: reqwest_middleware::ClientWithMiddleware) -> Self {
+    pub fn with_client_and_config(config: datadog::Configuration, client: reqwest_middleware::ClientWithMiddleware) -> Self {
         Self {config, client}
     }
 
@@ -152,14 +151,14 @@ impl {{ structName }} {
     {% if operation.description is defined %}
     {{ operation.description | block_comment }}
     {%- endif %}
-    pub async fn {{operation.operationId | snake_case}}(&self{% for name, parameter in requiredParams %}, {{name|variable_name}}: {{ get_type_for_parameter(parameter, version) }}{% endfor %}{% if operation|has_optional_parameter %}, params: {{operation.operationId}}OptionalParams{% endif %}) -> Result<{% if returnType %}{{returnType}}{% else %}(){% endif %}, Error<{{operation.operationId}}Error>> {
+    pub async fn {{operation.operationId | snake_case}}(&self{% for name, parameter in requiredParams %}, {{name|variable_name}}: {{ get_type_for_parameter(parameter, version) }}{% endfor %}{% if operation|has_optional_parameter %}, params: {{operation.operationId}}OptionalParams{% endif %}) -> Result<{% if returnType %}{{returnType}}{% else %}(){% endif %}, datadog::Error<{{operation.operationId}}Error>> {
         match self.{{operation.operationId | snake_case}}_with_http_info({% for name, parameter in requiredParams %}{{name|variable_name}}{% if loop.last %}{% if operation|has_optional_parameter %}, {% endif %}{% else %}, {% endif %}{% endfor %}{% if operation|has_optional_parameter %} params{% endif %}).await {
             {%- if returnType %}
             Ok(response_content) => {
                 if let Some(e) = response_content.entity {
                     Ok(e)
                 } else {
-                    Err(Error::Serde(serde::de::Error::custom("response content was None")))
+                    Err(datadog::Error::Serde(serde::de::Error::custom("response content was None")))
                 }
             },
             {%- else%}
@@ -178,7 +177,7 @@ impl {{ structName }} {
 
     pub fn {{operation.operationId | snake_case}}_with_pagination(
         &self{% for name, parameter in requiredParams %}, {% if limitParamParts[0] == name|variable_name %}mut {% endif %} {{name|variable_name}}: {{ get_type_for_parameter(parameter, version) }}{% endfor %}{% if operation|has_optional_parameter %}, mut params: {{operation.operationId}}OptionalParams{% endif %}
-    ) -> impl Stream<Item = Result<{{ itemType }}, Error<{{ operation.operationId }}Error>>> + '_
+    ) -> impl Stream<Item = Result<{{ itemType }}, datadog::Error<{{ operation.operationId }}Error>>> + '_
     {
         try_stream! {
             {#- Limit param part fields #}
@@ -280,17 +279,17 @@ impl {{ structName }} {
     {% if operation.description is defined %}
     {{ operation.description | block_comment }}
     {%- endif %}
-    pub async fn {{operation.operationId | snake_case}}_with_http_info(&self{% for name, parameter in requiredParams %}, {{name|variable_name}}: {{ get_type_for_parameter(parameter, version) }}{% endfor %}{% if operation|has_optional_parameter %}, params: {{operation.operationId}}OptionalParams{% endif %}) -> Result<ResponseContent<{% if returnType %}{{returnType}}{% else %}(){% endif %}>, Error<{{operation.operationId}}Error>> {
+    pub async fn {{operation.operationId | snake_case}}_with_http_info(&self{% for name, parameter in requiredParams %}, {{name|variable_name}}: {{ get_type_for_parameter(parameter, version) }}{% endfor %}{% if operation|has_optional_parameter %}, params: {{operation.operationId}}OptionalParams{% endif %}) -> Result<datadog::ResponseContent<{% if returnType %}{{returnType}}{% else %}(){% endif %}>, datadog::Error<{{operation.operationId}}Error>> {
         let local_configuration = &self.config;
         let operation_id = "{{ version }}.{{ operation.operationId | snake_case }}";
         {%- if "x-unstable" in operation %}
         if local_configuration.is_unstable_operation_enabled(operation_id) {
             warn!("Using unstable operation {operation_id}");
         } else {
-            let local_error = UnstableOperationDisabledError {
+            let local_error = datadog::UnstableOperationDisabledError {
                 msg: "Operation '{{ version }}.{{ operation.operationId | snake_case }}' is not enabled".to_string(),
             };
-            return Err(Error::UnstableOperationDisabledError(local_error));
+            return Err(datadog::Error::UnstableOperationDisabledError(local_error));
         }
         {%- endif %}
 
@@ -308,7 +307,7 @@ impl {{ structName }} {
             local_configuration.get_operation_host(operation_id)
             {%- for name, parameter in operation|parameters if parameter.in == "path" %}, {{ name|variable_name }}=
             {%- if parameter.schema.type == "string" %}
-            urlencode({{ name|variable_name }}{% if not parameter.required %}.unwrap(){% elif parameter.schema.nullable %}.unwrap(){% endif %}{% if parameter.schema.type == "array" %}.join(",").as_ref(){% endif %})
+            datadog::urlencode({{ name|variable_name }}{% if not parameter.required %}.unwrap(){% elif parameter.schema.nullable %}.unwrap(){% endif %}{% if parameter.schema.type == "array" %}.join(",").as_ref(){% endif %})
             {%- else %}
             {{ name|variable_name }}{% if not parameter.required %}.unwrap(){% elif parameter.schema.nullable %}.unwrap(){% endif %}{% if parameter.schema.type == "array" %}.join(",").as_ref(){% endif %}
             {%- endif %}
@@ -372,7 +371,7 @@ impl {{ structName }} {
                 log::warn!("Failed to parse user agent header: {e}, falling back to default");
                 headers.insert(
                     reqwest::header::USER_AGENT,
-                    HeaderValue::from_static(configuration::DEFAULT_USER_AGENT.as_str()),
+                    HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()),
                 )
             }
         };
@@ -412,7 +411,7 @@ impl {{ structName }} {
         {%- if operation.requestBody is defined and not formParameter %}
         // build body parameters
         let output = Vec::new();
-        let mut ser = serde_json::Serializer::with_formatter(output, DDFormatter);
+        let mut ser = serde_json::Serializer::with_formatter(output, datadog::DDFormatter);
         if {{operation.get("x-codegen-request-body-name", "body")|variable_name}}.serialize(&mut ser).is_ok() {
             if let Some(content_encoding) = headers.get("Content-Encoding") {
                 match content_encoding.to_str().unwrap_or_default() {
@@ -426,7 +425,7 @@ impl {{ structName }} {
                             Ok(buf) => {
                                 local_req_builder = local_req_builder.body(buf);
                             }
-                            Err(e) => return Err(Error::Io(e)),
+                            Err(e) => return Err(datadog::Error::Io(e)),
                         }
                     }
                     "deflate" => {
@@ -439,7 +438,7 @@ impl {{ structName }} {
                             Ok(buf) => {
                                 local_req_builder = local_req_builder.body(buf);
                             }
-                            Err(e) => return Err(Error::Io(e)),
+                            Err(e) => return Err(datadog::Error::Io(e)),
                         }
                     }
                     "zstd1" => {
@@ -449,7 +448,7 @@ impl {{ structName }} {
                             Ok(buf) => {
                                 local_req_builder = local_req_builder.body(buf);
                             }
-                            Err(e) => return Err(Error::Io(e)),
+                            Err(e) => return Err(datadog::Error::Io(e)),
                         }
                     }
                     _ => {
@@ -471,31 +470,31 @@ impl {{ structName }} {
 
         if !local_status.is_client_error() && !local_status.is_server_error() {
             {%- if returnType == "Vec<u8>" %}
-            Ok(ResponseContent {
+            Ok(datadog::ResponseContent {
                 status: local_status,
                 content: local_content.clone(),
                 entity: Some(local_content.into_bytes()),
             })
             {%- elif returnType %}
             match serde_json::from_str::<{{ returnType }}>(&local_content) {
-                Ok(e) => return Ok(ResponseContent {
+                Ok(e) => return Ok(datadog::ResponseContent {
                     status: local_status,
                     content: local_content,
                     entity: Some(e),
                 }),
-                Err(e) => return Err(crate::datadog::Error::Serde(e)),
+                Err(e) => return Err(datadog::Error::Serde(e)),
             };
             {%- else %}
-            Ok(ResponseContent {
+            Ok(datadog::ResponseContent {
                 status: local_status,
                 content: local_content,
                 entity: None,
             })
             {%- endif %}
         } else {
             let local_entity: Option<{{operation.operationId}}Error> = serde_json::from_str(&local_content).ok();
-            let local_error = ResponseContent { status: local_status, content: local_content, entity: local_entity };
-            Err(Error::ResponseError(local_error))
+            let local_error = datadog::ResponseContent { status: local_status, content: local_content, entity: local_entity };
+            Err(datadog::Error::ResponseError(local_error))
         }
     }
     {%- endfor %}

.generator/src/generator/templates/common_mod.j2

@@ -2,6 +2,9 @@ use std::error;
 use std::fmt;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
+mod configuration;
+pub use configuration::{Configuration, APIKey, DEFAULT_USER_AGENT};
+
 #[derive(Debug, Clone)]
 pub struct ResponseContent<T> {
     pub status: reqwest::StatusCode,
@@ -75,38 +78,11 @@ impl <T> From<std::io::Error> for Error<T> {
     }
 }
 
-pub fn urlencode<T: AsRef<str>>(s: T) -> String {
+pub(crate) fn urlencode<T: AsRef<str>>(s: T) -> String {
     ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect()
 }
 
-pub fn parse_deep_object(prefix: &str, value: &serde_json::Value) -> Vec<(String, String)> {
-    if let serde_json::Value::Object(object) = value {
-        let mut params = vec![];
-
-        for (key, value) in object {
-            match value {
-                serde_json::Value::Object(_) => params.append(&mut parse_deep_object(
-                    &format!("{}[{}]", prefix, key),
-                    value,
-                )),
-                serde_json::Value::Array(array) => {
-                    for (i, value) in array.iter().enumerate() {
-                        params.append(&mut parse_deep_object(
-                            &format!("{}[{}][{}]", prefix, key, i),
-                            value,
-                        ));
-                    }
-                },
-                serde_json::Value::String(s) => params.push((format!("{}[{}]", prefix, key), s.clone())),
-                _ => params.push((format!("{}[{}]", prefix, key), value.to_string())),
-            }
-        }
-        return params;
-    }
-    unimplemented!("Only objects are supported with style=deepObject")
-}
-
-pub struct DDFormatter;
+pub(crate) struct DDFormatter;
 
 impl serde_json::ser::Formatter for DDFormatter {
     fn write_f64<W>(&mut self, writer: &mut W, value: f64) -> std::io::Result<()>
@@ -117,8 +93,6 @@ impl serde_json::ser::Formatter for DDFormatter {
     }
 }
 
-pub mod configuration;
-
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct UnparsedObject {
     pub value: serde_json::Value,

.generator/src/generator/templates/example.j2

@@ -5,8 +5,8 @@
 {%- if context.body %}
 {%- set body, imports = format_data_with_schema(context.body.value, context.api_request.schema.spec, replace_values=context._replace_values, required=True, variables=variables, version=version|upper, imports=imports)%}
 {%- endif %}
-use datadog_api_client::datadog::configuration::Configuration;
-use datadog_api_client::datadog{{ version|upper }}::api::api_{{context["api_instance"]["name"] | snake_case}}::{{context["api_instance"]["name"]}}API;
+use datadog_api_client::datadog;
+use datadog_api_client::datadog{{ version|upper }}::api_{{context["api_instance"]["name"] | snake_case}}::{{context["api_instance"]["name"]}}API;
 {%- for name in imports %}
 use {{name}};
 {%- endfor %}
@@ -37,7 +37,7 @@ async fn main() {
 	let body = {{ body }};
     {%- endif %}
 
-    let {% if context._enable_operations %}mut{% endif %} configuration = Configuration::new();
+    let {% if context._enable_operations %}mut{% endif %} configuration = datadog::Configuration::new();
 
     {%- for operation in context._enable_operations %}
 	configuration.set_unstable_operation_enabled("{{ version }}.{{ operation }}", true);

.generator/src/generator/templates/function_mappings.j2

@@ -16,7 +16,7 @@ pub struct ApiInstances {
 {%- for name, operations in apis.items() %}
 {%- set fieldName = "api_"+name %}
 {%- set structName = name.replace(" ", "")+"API" %}
-    pub {{version}}_{{fieldName | snake_case}}: Option<datadog{{ version.upper() }}::api::{{fieldName | snake_case}}::{{structName}}>,
+    pub {{version}}_{{fieldName | snake_case}}: Option<datadog{{ version.upper() }}::{{fieldName | snake_case}}::{{structName}}>,
 {%- endfor %}
 {%- endfor %}
 }
@@ -28,7 +28,7 @@ pub fn initialize_api_instance(world: &mut DatadogWorld, api: String) {
     {%- set structName = name.replace(" ", "")+"API" %}
         "{{name.replace(" ", "")}}" => {
         {%- for version in versions %}
-            world.api_instances.{{version}}_{{fieldName}} = Some(datadog{{ version.upper() }}::api::{{fieldName}}::{{structName}}::with_client_and_config(
+            world.api_instances.{{version}}_{{fieldName}} = Some(datadog{{ version.upper() }}::{{fieldName}}::{{structName}}::with_client_and_config(
                 world.config.clone(),
                 world.http_client.as_ref().unwrap().clone()
             ));
@@ -81,7 +81,7 @@ fn test_{{version}}_{{ operation['operationId'] | snake_case }}(world: &mut Data
 
     {%- for parameter in optionalParams %}
     {%- if loop.first %}
-    let mut params = datadog{{ version.upper() }}::api::{{ apiName }}::{{ operation['operationId'] }}OptionalParams::default();
+    let mut params = datadog{{ version.upper() }}::{{ apiName }}::{{ operation['operationId'] }}OptionalParams::default();
     {%- endif %}
     params.{{ parameter[0] | variable_name }} = {{ parameter[0] | variable_name }};
     {%- if loop.last %}
@@ -130,7 +130,7 @@ fn test_{{version}}_{{ operation['operationId'] | snake_case }}_with_pagination(
 
     {%- for parameter in optionalParams %}
     {%- if loop.first %}
-    let mut params = datadog{{ version.upper() }}::api::{{ apiName }}::{{ operation['operationId'] }}OptionalParams::default();
+    let mut params = datadog{{ version.upper() }}::{{ apiName }}::{{ operation['operationId'] }}OptionalParams::default();
     {%- endif %}
     params.{{ parameter[0] | variable_name }} = {{ parameter[0] | variable_name }};
     {%- if loop.last %}

.generator/src/generator/templates/lib.j2

@@ -1,6 +1,7 @@
 {% include "partial_header.j2" %}
 #![allow(non_camel_case_types)]
 #![allow(non_snake_case)]
+#![doc = include_str!("../README.md")]
 
 pub mod datadog;
 pub mod datadogV1;

.generator/src/generator/templates/mod.j2

@@ -1,4 +1,8 @@
 {% include "partial_header.j2" %}
 
 pub mod api;
+{%- for name, operations in apis.items() %}
+{%- set classname = "api_"+name%}
+pub use self::api::{{classname | snake_case}};
+{%- endfor %}
 pub mod model;

README.md

@@ -20,8 +20,8 @@ datadog-api-client = "0"
 
 Please follow the [installation](#installation) instructions and try the following snippet to validate your Datadog API key:
 
-```Rust
-use datadog_api_client::datadog::configuration::Configuration;
+```rust
+use datadog_api_client::datadog::Configuration;
 use datadog_api_client::datadogV1::api::api_authentication::AuthenticationAPI;
 
 #[tokio::main]

examples/v1_authentication_validate.rs

@@ -1,10 +1,10 @@
 // Validate API key returns "OK" response
-use datadog_api_client::datadog::configuration::Configuration;
-use datadog_api_client::datadogV1::api::api_authentication::AuthenticationAPI;
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV1::api_authentication::AuthenticationAPI;
 
 #[tokio::main]
 async fn main() {
-    let configuration = Configuration::new();
+    let configuration = datadog::Configuration::new();
     let api = AuthenticationAPI::with_config(configuration);
     let resp = api.validate().await;
     if let Ok(value) = resp {

examples/v1_aws-integration_create_aws_account.rs

@@ -1,6 +1,6 @@
 // Create an AWS integration returns "OK" response
-use datadog_api_client::datadog::configuration::Configuration;
-use datadog_api_client::datadogV1::api::api_aws_integration::AWSIntegrationAPI;
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV1::api_aws_integration::AWSIntegrationAPI;
 use datadog_api_client::datadogV1::model::AWSAccount;
 use std::collections::BTreeMap;
 
@@ -16,7 +16,7 @@ async fn main() {
         .metrics_collection_enabled(false)
         .resource_collection_enabled(true)
         .role_name("DatadogAWSIntegrationRole".to_string());
-    let configuration = Configuration::new();
+    let configuration = datadog::Configuration::new();
     let api = AWSIntegrationAPI::with_config(configuration);
     let resp = api.create_aws_account(body).await;
     if let Ok(value) = resp {

examples/v1_aws-integration_create_aws_event_bridge_source.rs

@@ -1,6 +1,6 @@
 // Create an Amazon EventBridge source returns "OK" response
-use datadog_api_client::datadog::configuration::Configuration;
-use datadog_api_client::datadogV1::api::api_aws_integration::AWSIntegrationAPI;
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV1::api_aws_integration::AWSIntegrationAPI;
 use datadog_api_client::datadogV1::model::AWSEventBridgeCreateRequest;
 
 #[tokio::main]
@@ -10,7 +10,7 @@ async fn main() {
         .create_event_bus(true)
         .event_generator_name("app-alerts".to_string())
         .region("us-east-1".to_string());
-    let configuration = Configuration::new();
+    let configuration = datadog::Configuration::new();
     let api = AWSIntegrationAPI::with_config(configuration);
     let resp = api.create_aws_event_bridge_source(body).await;
     if let Ok(value) = resp {