solve circular import

src/python-generator/exporter.clj

@@ -9,34 +9,39 @@
   (:gen-class))
 
 (defn base-index []
+  (helpers/write-to-file "/Users/gena.razmakhnin/Documents/aidbox-sdk-js/test_dir/base", "__init__", "")
   (->> (helpers/parse-ndjson-gz "/Users/gena.razmakhnin/Documents/aidbox-sdk-js/fhir-schema/hl7.fhir.r4.core#4.0.1/package.ndjson.gz")
        (extractors/filter-base)
        (map (fn [definition] (str "from base." (clojure.string/lower-case (helpers/get-resource-name (:type definition))) " import " (helpers/get-resource-name (:type definition)) "\n")))
        (clojure.string/join)
        (helpers/write-to-file "/Users/gena.razmakhnin/Documents/aidbox-sdk-js/test_dir/base", "index")))
 
 (defn element-index []
+  (helpers/write-to-file "/Users/gena.razmakhnin/Documents/aidbox-sdk-js/test_dir/element", "__init__", "")
   (->> (helpers/parse-ndjson-gz "/Users/gena.razmakhnin/Documents/aidbox-sdk-js/fhir-schema/hl7.fhir.r4.core#4.0.1/package.ndjson.gz")
        (extractors/filter-element)
        (map (fn [definition] (str "from element." (clojure.string/lower-case (helpers/get-resource-name (:type definition))) " import " (helpers/get-resource-name (:type definition)) "\n")))
        (clojure.string/join)
        (helpers/write-to-file "/Users/gena.razmakhnin/Documents/aidbox-sdk-js/test_dir/element", "index")))
 
 (defn resource-index []
+  (helpers/write-to-file "/Users/gena.razmakhnin/Documents/aidbox-sdk-js/test_dir/resource", "__init__", "")
   (->> (helpers/parse-ndjson-gz "/Users/gena.razmakhnin/Documents/aidbox-sdk-js/fhir-schema/hl7.fhir.r4.core#4.0.1/package.ndjson.gz")
        (extractors/filter-resource)
        (map (fn [definition] (str "from resource." (clojure.string/lower-case (helpers/get-resource-name (:type definition))) " import " (helpers/get-resource-name (:type definition)) "\n")))
        (clojure.string/join)
        (helpers/write-to-file "/Users/gena.razmakhnin/Documents/aidbox-sdk-js/test_dir/resource", "index")))
 
 (defn backbone-index []
+  (helpers/write-to-file "/Users/gena.razmakhnin/Documents/aidbox-sdk-js/test_dir/backbone", "__init__", "")
   (->> (helpers/parse-ndjson-gz "/Users/gena.razmakhnin/Documents/aidbox-sdk-js/fhir-schema/hl7.fhir.r4.core#4.0.1/package.ndjson.gz")
        (extractors/filter-backbone-element)
        (map (fn [definition] (str "from backbone." (clojure.string/lower-case (helpers/get-resource-name (:type definition))) " import " (helpers/get-resource-name (:type definition)) "\n")))
        (clojure.string/join)
        (helpers/write-to-file "/Users/gena.razmakhnin/Documents/aidbox-sdk-js/test_dir/backbone", "index")))
 
 (defn domain-index []
+  (helpers/write-to-file "/Users/gena.razmakhnin/Documents/aidbox-sdk-js/test_dir/domain", "__init__", "")
   (->> (helpers/parse-ndjson-gz "/Users/gena.razmakhnin/Documents/aidbox-sdk-js/fhir-schema/hl7.fhir.r4.core#4.0.1/package.ndjson.gz")
        (extractors/filter-domain-resource)
        (map (fn [definition] (str "from domain." (clojure.string/lower-case (helpers/get-resource-name (:type definition))) " import " (helpers/get-resource-name (:type definition)) "\n")))

src/python-generator/helpers.clj

@@ -3,12 +3,12 @@
    [python-generator.extractor]
    [cheshire.core]
    [clojure.java.io :as io]
-   [clojure.string :as str]
-   [edamame.core :as e]))
+   [clojure.string :as str]))
 
 
 ;; TODO: do not hardcode
 (def elements #{"HumanName" "Signature" "Range" "Coding" "Attachment" "BackboneElement" "Address" "Money" "Period" "Expression" "TriggerDefinition" "Contributor" "Identifier" "Extension" "Quantity" "RelatedArtifact" "Ratio" "UsageContext" "ContactPoint" "Narrative" "Meta" "SampledData" "Annotation" "Reference" "CodeableConcept" "ContactDetail" "ParameterDefinition" "DataRequirement"})
+(def backbone-elements #{"Population" "Timing" "MarketingStatus" "SubstanceAmount" "ProductShelfLife" "ProdCharacteristic" "Dosage" "ElementDefinition"})
 (def primitives-string #{"dateTime" "xhtml" "Distance" "time" "date" "string" "uuid" "oid" "id" "Dosage" "Duration" "instant" "Count" "decimal" "code" "base64Binary" "unsignedInt" "url" "markdown" "uri" "positiveInt"  "canonical" "Age" "Timing"})
 
 (defn escape-keyword [word]
@@ -27,7 +27,6 @@
   (last (str/split (str reference) #"/")))
 
 (defn get-type [type]
-  (if (nil? type) (print "FUCK YOU") ())
   (cond
     (= type "boolean") "bool"
     (= type "integer") "int"
@@ -65,17 +64,24 @@
 
 (defn collect-imports [[_, v]]
   (let [type (derive-basic-type (:type v))]
-    (print type)
     (if (.contains elements type) type nil)))
 
-(defn ttt [data]
-  (print data)
+(defn collect-backbone-imports [[_, v]]
+  (let [type (derive-basic-type (:type v))]
+    (if (.contains backbone-elements type) type nil)))
+
+(defn add-element-import [data]
   (clojure.string/join (map (fn [item] (str "from element.index import " item "\n")), data)))
 
+(defn add-backbone-element-import [data]
+  (clojure.string/join (map (fn [item] (str "from backbone.index import " item "\n")), data)))
+
 (defn get-typings-and-imports [required, data]
   (reduce (fn [acc, item]
             (hash-map :elements (conj (:elements acc) (collect-types required item))
-                      :imports (conj (:imports acc) (collect-imports item)))) (hash-map :elements [] :imports []) data))
+                      :imports-element (conj (:imports-element acc) (collect-imports item))
+                      :imports-backbone-element (conj (:imports-backbone-element acc) (collect-backbone-imports item))))
+          (hash-map :elements [] :imports-element [] :imports-backbone-element []) data))
 
 (defn parse-ndjson-gz [path]
   (with-open [rdr (-> path

src/python-generator/index.clj

@@ -9,20 +9,29 @@
 (defn save-to [directory, filename]
   (fn [text] (helpers/write-to-file directory, filename, text)))
 
+(defn push-to-end [string1, string2] (str string2, string1))
+
+(defn ignore [data]
+  (clojure.string/join (map (fn [item] (str "\t" item " = Any\n")), data)))
+
+(defn typechecking-ignore-runtime [string]
+  (fn [inner_string] (str inner_string string "\n")))
+
 (defn combine-file [definition, data]
-  (->  (filter boolean (:imports data))
-       (helpers/ttt)
-       (str "\n")
-       ((if (= (helpers/get-resource-name (:base definition)) "DomainResource") (fn [string] (str "from resource.index import DomainResource\n" string)) str))
-       ((if (= (helpers/get-resource-name (:base definition)) "Resource") (fn [string] (str "from base.resource import Resource\n" string)) str))
-       ((if (= (helpers/get-resource-name (:base definition)) "BackboneElement") (fn [string] (str "from element.index import BackboneElement\nfrom base.index import Element\n" string)) str))
-       ((if (= (helpers/get-resource-name (:base definition)) "Element") (fn [string] (str "from base.index import Element\n" string)) str))
-       (str "from typing import Optional, Any\n\n\n")
-       (str "class " (helpers/get-resource-name (:type definition)) "Origin" (helpers/get-parent (:base definition)) ":\n")
+  (->  (str (helpers/add-element-import (filter boolean (:imports-element data))))
+       (str (helpers/add-backbone-element-import (filter boolean (:imports-backbone-element data))))
+       #_(push-to-end (str "if TYPE_CHECKING:\n\t\"import typings\"\n"))
+       (push-to-end (str "from typing import TYPE_CHECKING, Optional, Any\n\n"))
+       #_(push-to-end (str "from __future__ import annotations\n"))
+       #_(str "else:\n\t\"import typings\"\n")
+       #_((typechecking-ignore-runtime (ignore (filter boolean (:imports data)))))
+       ((if (= (helpers/get-resource-name (:base definition)) "DomainResource") (fn [string] (str string "from resource.index import DomainResource\n\n")) str))
+       ((if (= (helpers/get-resource-name (:base definition)) "Resource") (fn [string] (str string "from base.resource import Resource\n\n")) str))
+       ((if (= (helpers/get-resource-name (:base definition)) "BackboneElement") (fn [string] (str string "from element.index import BackboneElement\nfrom base.index import Element\n\n")) str))
+       ((if (= (helpers/get-resource-name (:base definition)) "Element") (fn [string] (str string "from base.index import Element\n\n")) str))
+       (str "\nclass " (helpers/get-resource-name (:type definition)) "Origin" (helpers/get-parent (:base definition)) ":\n")
        (str (clojure.string/join "\n" (:elements data)) "\n\n")))
 
-(defn push-to-end [string1, string2] (str string2, string1))
-
 (defn compile-single-class [directory]
   (fn [definition]
     (->> (helpers/elements-to-vector definition)