     public func acquireSecurizedURLFrom(originalURL: URL, appScoped: Bool=false) throws ->URL {
         do{
             if originalURL.isFileURL == false{
-                Swift.print("acquireSecurizedURLFrom(\(originalURL) -> returns URL distant or not )")
                 return originalURL
             }
 
             if originalURL.isInMainBundle{
-                Swift.print("acquireSecurizedURLFrom(\(originalURL) -> returns bundled URL )")
                 return originalURL
+            }
+
+            if !appScoped && self.isDraft{
+                // The document must have an URL to create a Bookmark
+                throw SecurityScopedBookMarkError.documentIsADraft
             }
 
             if let url=self._normalizeFileURL(originalURL){
                 if !FileManager.default.fileExists(atPath: url.path){
                     throw SecurityScopedBookMarkError.unexistingLocalFile
                 }
-
-                Swift.print("acquireSecurizedURLFrom(\(url))")
                 if self._securityScopedBookmarkExits(url, appScoped: false) {
                     // The bookmark data exists
                     let key=self._getBookMarkKeyFor(url, appScoped: appScoped)
                     if let securizedURL=self._activeSecurityBookmarks[key]{
-                        // The Url has already been acquired
-                        Swift.print("returns \(securizedURL)")
                         return securizedURL
                     }else{
                         if let idx=self.metadata.URLBookmarkData.index(where:{$0.key == key}){
                             //  Acquire the securized URL
                             let data=self.metadata.URLBookmarkData[idx].data
-                            let securizedURL = try self._getSecurityScopedURLFrom(data)
+                            let securizedURL = try self._getSecurityScopedURLFrom(data,forKey:key)
                             self._startAccessingToSecurityScopedResourceAtURL(key,securizedURL)
-                            Swift.print("returns \(securizedURL)")
                             return securizedURL
                         }else{
-                            Swift.print("returns Void data when attempting to acquire securized URL")
                             throw SecurityScopedBookMarkError.voidData
                         }
                     }
                 }else{
                     // try to create and acquire
                     let r = try self._bookmarkURL(url, appScoped: false)
-                    // Return the securized url
-                    Swift.print("returns \(r.securizedURL)")
                     return r.securizedURL
                 }
             }else{
                 throw SecurityScopedBookMarkError.URLNormalizationIssue
             }
-
-
         }catch{
-            Swift.print("returns Exception \(error)")
             throw error
         }
     }

            self.metadata.URLBookmarkData.append(keyedData)

            // Prepare to return the key and the securized URL
            let securizedURL = try self._getSecurityScopedURLFrom(data)
            self._startAccessingToSecurityScopedResourceAtURL(key,securizedURL)
            self.hasChanged()


            if (!bookmarkIsStale) {
                return securizedURL!
            } else {
                // Delete the bookmark
                if let idx=self.metadata.URLBookmarkData.index(where:{ $0.key == forKey }){
                    self.metadata.URLBookmarkData.remove(at: idx)
                }
                throw SecurityScopedBookMarkError.bookMarkIsStale
            }
        } catch {
            // Delete the bookmark
            if let idx=self.metadata.URLBookmarkData.index(where:{ $0.key == forKey }){
                self.metadata.URLBookmarkData.remove(at: idx)
            }

            throw SecurityScopedBookMarkError.getScopedURLRessourceFailed(message: "\(error)")
        }
    }
