|
amateur developer, basf employee & Pirat from Dormagen, Germany
|
Authorities in Greece have arrested six people on the island of Crete in connection with an alleged antiquities smuggling ring that was attempting to sell dozens of ancient artifacts, police said Thursday. The arrests came after a sting operation on Wednesday, during which the suspects were reportedly trying to sell a collection of antiquities to […]
The post Dozens of antiquities seized in Crete smuggling raid, 6 arrests appeared first on Keep Talking Greece.
“Only Apple can do this” Variously attributed to Tim Cook
Apple introduced Apple Intelligence at WWDC 2024. After waiting almost a year for Apple to, in Craig Federighi’s words, “get it right”, its promise of “AI for the rest of us” feels just as distant as ever.
While we wait for Apple Intelligence to arrive on our devices, something remarkable is already running on our Macs. Think of it as a locavore approach to artificial intelligence: homegrown, sustainable, and available year-round.
This week on NSHipster, we’ll look at how you can use Ollama to run LLMs locally on your Mac — both as an end-user and as a developer.
Ollama is the easiest way to run large language models on your Mac. You can think of it as “Docker for LLMs” - a way to pull, run, and manage AI models as easily as containers.
Download Ollama with Homebrew or directly from their website. Then pull and run llama3.2 (2GB).
Log in
$ brew install --cask ollama
$ ollama run llama3.2
>>> Tell me a joke about Swift programming.
What's a Apple developer's favorite drink?
The Kool-Aid.
Under the hood, Ollama is powered by llama.cpp. But where llama.cpp provides the engine, Ollama gives you a vehicle you’d actually want to drive — handling all the complexity of model management, optimization, and inference.
Similar to how Dockerfiles define container images, Ollama uses Modelfiles to configure model behavior:
FROM mistral:latest
PARAMETER temperature 0.7
TEMPLATE """
You are a helpful assistant.
User:
Assistant: """
Ollama uses the Open Container Initiative (OCI) standard to distribute models. Each model is split into layers and described by a manifest, the same approach used by Docker containers:
{
"mediaType": "application/vnd.oci.image.manifest.v1+json",
"config": {
"mediaType": "application/vnd.ollama.image.config.v1+json",
"digest": "sha256:..."
},
"layers": [
{
"mediaType": "application/vnd.ollama.image.layer.v1+json",
"digest": "sha256:...",
"size": 4019248935
}
]
}
Overall, Ollama’s approach is thoughtful and well-engineered. And best of all, it just works.
Jevons paradox states that, as something becomes more efficient, we tend to use more of it, not less.
Having AI on your own device changes everything. When computation becomes essentially free, you start to see intelligence differently.
While frontier models like GPT-4 and Claude are undeniably miraculous, there’s something to be said for the small miracle of running open models locally.
/M\d Mac((Book( Pro| Air)?)|Mini|Studio)/ can easily generate dozens of tokens per second.
(Try to keep up!)Ollama also exposes an HTTP API on port 11431 (leetspeak for llama 🦙). This makes it easy to integrate with any programming language or tool.
To that end, we’ve created the Ollama Swift package to help developers integrate Ollama into their apps.
The simplest way to use a language model is to generate text from a prompt:
import Ollama
let client = Client.default
let response = try await client.generate(
model: "llama3.2",
prompt: "Tell me a joke about Swift programming.",
options: ["temperature": 0.7]
)
print(response.response)
// How many Apple engineers does it take to document an API?
// None - that's what WWDC videos are for.
For more structured interactions, you can use the chat API to maintain a conversation with multiple messages and different roles:
let initialResponse = try await client.chat(
model: "llama3.2",
messages: [
.system("You are a helpful assistant."),
.user("What city is Apple located in?")
]
)
print(initialResponse.message.content)
// Apple's headquarters, known as the Apple Park campus, is located in Cupertino, California.
// The company was originally founded in Los Altos, California, and later moved to Cupertino in 1997.
let followUp = try await client.chat(
model: "llama3.2",
messages: [
.system("You are a helpful assistant."),
.user("What city is Apple located in?"),
.assistant(initialResponse.message.content),
.user("Please summarize in a single word")
]
)
print(followUp.message.content)
// Cupertino
Embeddings convert text into high-dimensional vectors that capture semantic meaning. These vectors can be used to find similar content or perform semantic search.
For example, if you wanted to find documents similar to a user’s query:
let documents: [String] = …
// Convert text into vectors we can compare for similarity
let embeddings = try await client.embeddings(
model: "nomic-embed-text",
texts: documents
)
/// Finds relevant documents
func findRelevantDocuments(
for query: String,
threshold: Float = 0.7, // cutoff for matching, tunable
limit: Int = 5
) async throws -> [String] {
// Get embedding for the query
let [queryEmbedding] = try await client.embeddings(
model: "llama3.2",
texts: [query]
)
// See: https://en.wikipedia.org/wiki/Cosine_similarity
func cosineSimilarity(_ a: [Float], _ b: [Float]) -> Float {
let dotProduct = zip(a, b).map(*).reduce(0, +)
let magnitude = { sqrt($0.map { $0 * $0 }.reduce(0, +)) }
return dotProduct / (magnitude(a) * magnitude(b))
}
// Find documents above similarity threshold
let rankedDocuments = zip(embeddings, documents)
.map { embedding, document in
(similarity: cosineSimilarity(embedding, queryEmbedding),
document: document)
}
.filter { $0.similarity >= threshold }
.sorted { $0.similarity > $1.similarity }
.prefix(limit)
return rankedDocuments.map(\.document)
}
Embeddings really shine when combined with text generation in a RAG (Retrieval Augmented Generation) workflow. Instead of asking the model to generate information from its training data, we can ground its responses in our own documents by:
Here’s a simple example:
let query = "What were AAPL's earnings in Q3 2024?"
let relevantDocs = try await findRelevantDocuments(query: query)
let context = """
Use the following documents to answer the question.
If the answer isn't contained in the documents, say so.
Documents:
\(relevantDocs.joined(separator: "\n---\n"))
Question: \(query)
"""
let response = try await client.generate(
model: "llama3.2",
prompt: context
)
To summarize: Different models have different capabilities.
Models like llama3.2-vision can take images along with text as inputs.
With Ollama, you get unlimited access to a wealth of these and many more open-source language models.
So, what can you build with all of this?
Here’s just one example:
Nominate is a macOS app that uses Ollama to intelligently rename PDF files based on their contents.
Like many of us striving for a paperless lifestyle,
you might find yourself scanning documents only to end up with
cryptically-named PDFs like Scan2025-02-03_123456.pdf.
Nominate solves this by combining AI with traditional NLP techniques
to automatically generate descriptive filenames based on document contents.
The app leverages several technologies we’ve discussed:
ollama-swift packageDateFormatter for parsing dates“The future is already here – it’s just not evenly distributed yet.” William Gibson
Think about the timelines:
If you wait for Apple to deliver on its promises, you’re going to miss out on the most important technological shift in a generation.
The future is here today. You don’t have to wait. With Ollama, you can start building the next generation of AI-powered apps right now.
Vor der chilenischen Küste Patagoniens hat ein Buckelwal kurzzeitig einen Kajakfahrer in seinem Maul, bevor er ihn schnell wieder unverletzt freiließ.
Ein Vater und sein Sohn waren gemeinsam Kajak fahren, als der riesige Wal plötzlich auftauchte und den jungen Mann samt gelbem Kajak für einige Sekunden in seinem Maul gefangen hielt, bevor er ihn recht fix wieder auspuckte. Der Vater filmte den Vorfall. Holy Moly!
(Direktlink, via MeFi)
In this post we are going to build a bar chart, comparing durations of nature walks in the Christchurch area. We will be using the new Swift Charts framework introduced this year and will see how to plot data of types that don't conform to Plottable protocol by default such as Measurement<UnitDuration>.
Let's start by defining the data to visualize in the chart.
We declare a Walk struct containing the title and the duration of the walk in hours. We use the Measurement type from Foundation framework with the unit type of UnitDuration to represent the duration of each walk.
struct Walk {
let title: String
let duration: Measurement<UnitDuration>
}
We store the walks to show in the chart in an array.
let walks = [
Walk(
title: "Taylors Mistake to Sumner Beach Coastal Walk",
duration: Measurement(value: 3.1, unit: .hours)
),
Walk(
title: "Bottle Lake Forest",
duration: Measurement(value: 2, unit: .hours)
),
Walk(
title: "Old Halswell Quarry Loop",
duration: Measurement(value: 0.5, unit: .hours)
),
...
]
Let's define a Chart and pass it the walks array for the data parameter. Since we know that our walk titles are unique, we can just use them as ids, but you can also conform your data model to Identifiable instead.
Chart(walks, id: \.title) { walk in
BarMark(
x: .value("Duration", walk.duration),
y: .value("Walk", walk.title)
)
}
Note, that because Measurement<UnitDuration> doesn't conform to Plottable protocol by default, we will get an error Initializer 'init(x:y:width:height:stacking:)' requires that 'Measurement<UnitDuration>' conform to 'Plottable'.
The BarkMark initializer expects to receive a PlottableValue for x and y parameters. And the value type of PlottableValue has to conform to Plottable protocol.
We have two options to fix the error. We can either extract the value of the measurement that is a Double and conforms to Plottable by default or we can extend Measurement<UnitDuration> with Plottable conformance.
If we simply extract the value from the measurement, we'll loose the context and won't know what units were used to create the measurement. This means that we won't be able to properly format the labels of the chart to represent the unit to the users. We could remember that we used hours when creating the measurement, but it's not ideal. We can decide to change the data model later to store the duration in minutes, for example, or the data could be coming from somewhere else, so manually reconstructing the units is not a perfect solution. We will look into how to make Measurement<UnitDuration> conform to Plottable instead.
Measurement is a generic type, so we need to specify the UnitType when extending it. Since we are using Measurement<UnitDuration> in our example, we will specify that UnitType equals UnitDuration, but you can adapt it to the measurements you are using in your own projects.
extension Measurement: Plottable where UnitType == UnitDuration {
public var primitivePlottable: Double {
self.converted(to: .minutes).value
}
public init?(primitivePlottable: Double) {
self.init(value: primitivePlottable, unit: .minutes)
}
}
Plottable protocol has two requirements: primitivePlottable property that has to return one of the primitive types such as Double, String or Date and a failable initializer that creates a value from a primitive plottable type.
I decided to convert the measurement to and from minutes, but you can choose any other unit that suits your needs. It's just important to use the same unit when converting to and from the primitive value.
With the Plottable conformance added, we can now check our chart. It works, but the labels on the x-axis are not formatted and don't show the units of measurements to the users. We are going to fix that next.
To customize the labels on the x-axis we will use chartXAxis(content:) modifier and reconstruct the axis marks with the values passed to us.
Chart(walks, id: \.title) { ... }
.chartXAxis {
AxisMarks { value in
AxisGridLine()
AxisValueLabel("""
\(value.as(Measurement.self)!
.converted(to: .hours),
format: .measurement(
width: .narrow,
numberFormatStyle: .number.precision(
.fractionLength(0))
)
)
""")
}
}
We first add the grid line and then reconstruct the label for a given value.
AxisValueLabel accepts a LocalizedStringKey in the initializer, that can be constructed by interpolating a measurement and indicating its format style.
The value we receive is created using the initializer we defined in the Plottable conformance, so in our case it is provided in minutes. But I believe it would be better to use hours for this particular chart. We can easily convert the measurement to the desired unit inside the interpolation. Here we are certain that the value is of type Measurement, so we can force unwrap the Measurement type cast.
I chose the narrow format and zero digits after the comma for the number style, but you can adjust these settings for your specific chart.
The final result displays formatted durations in hours on the x-axis.
You can get the full sample code for the project used in this post from our GitHub repo.
Fast 13 Millionen Menschen in Deutschland haben die Corona-Warn-App installiert. Experten hatten berechnet, dass sich nun erste positive Effekte zeigen dürften.
ARTE Concert verlängert die Sommerbriese in den Winter: Ab sofort veröffentlicht ARTE Concert jeden Mittwoch unter dem Stichwort „Metal Mercredi“ ein neues Konzert von der T-Stage. Zu sehen gibt’s das Ganze online auf arteconcert.com sowie auf den Facebook– und YouTube-Kanälen von ARTE Concert.
The post Metal Mercredi auf ARTE Concert (Live videos) appeared first on Summer Breeze.
Die Berliner Polizei hat vor einigen Tagen ein Youtube-Video veröffentlicht. Ich verstehe nicht so ganz, ob es jetzt in erster Linie um Imagepflege in eigener Sache geht. Oder um ein (weiteres) Bekenntnis gegen Fremdenfeindlichkeit, also an sich um eine eine Selbstverständlichkeit bei der Polizei. Oder vielleicht ist das Ziel ja ein Ehrenplatz im Schwarzbuch des Bundes der Steuerzahler. Falls letzteres, dieser Plan geht garantiert auf.
Aber seht selbst:
Weil das Video völlig überraschend doch eher nur verhaltene Zustimmung erfährt, stilisiert sich die Berliner Polizei jetzt sogar als Opfer von „Hass“. In einem Twitter-Beitrag heißt es:
Wenn ein #YouTube-Video gegen Hass zu einer Welle des Hasses führen kann, ist es Zeit ein Zeichen zu setzen und gemeinsam stärker für Toleranz und gegen Hetze im Netz einzustehen, denn:
Wer schweigt, stimmt zu!#DigitaleZivilcourage#LoveOutLoudhttps://t.co/8xgn7TSnZG
^tsm pic.twitter.com/9Azzx7zhY7— Polizei Berlin (@polizeiberlin) 22. Oktober 2018
Mal in aller Deutlichkeit: Wer schweigt, der stimmt gar nichts zu. Dieser ganze verkorkste Pathos in dem Video und die nun auch noch zur Schau getragene Weinerlichkeit sind vielmehr an Peinlichkeit kaum zu überbieten. Ich jedenfalls wünsche mir eine Polizei, die in jeder Situation und unabhängig von der Herkunft der Beteiligten ihre Arbeit ruhig, sachlich und besonnen macht. Wenn das geschieht, muss man sich auch an nix und niemanden so ranzwanzen wie der sonnenbebrillte „Homie“ in Uniform, für mich bislang unangefochten die Witzfigur des Monats.
Im Plenum haben die Abgeordneten die Vorlage aus dem Rechtsausschuss abgelehnt, wonach Plattformen hochgeladene Inhalte überwachen sollten.
Get the lowdown on Alamofire!
Alamofire is a Swift-based HTTP networking library for iOS and Mac OS X. It provides an elegant interface on top of Apple’s Foundation networking stack that simplifies a number of common networking tasks.
Alamofire provides chainable request/response methods, JSON parameter and response serialization, authentication, and many other features.
In this Alamofire tutorial, you’ll use Alamofire to perform basic networking tasks like uploading files and requesting data from a third-party RESTful API.
Alamofire’s elegance comes from the fact it was written from the ground up in Swift and does not inherit anything from its Objective-C counterpart, AFNetworking.
You should have a conceptual understanding of HTTP networking and some exposure to Apple’s networking classes such as URLSession.
While Alamofire does obscure some implementation details, it’s good to have some background knowledge if you ever need to troubleshoot your network requests.
Use the Download Materials button at the top or bottom of this tutorial to download the starter project.
The app for this Alamofire tutorial is named PhotoTagger. When complete, it will let you select an image from your library (or camera if you’re running on an actual device) and upload the image to a third-party service called Imagga. This service will perform some image recognition tasks to come up with a list of tags and primary colors for the image:
This project uses CocoaPods, so open it using the PhotoTagger.xcworkspace file.
Note:To learn more about CocoaPods, check out this tutorial by Joshua Greene, published right here on the site.
Build and run the project. You’ll see the following:
Click Select Photo and choose a photo. The background image will be replaced with the image you chose.
Open Main.storyboard and you’ll see the additional screens for displaying tags and colors have been added for you. All that remains is to upload the image and fetch the tags and colors.
Imagga is an image recognition Platform-as-a-Service that provides image tagging APIs for developers and businesses to build scalable, image-intensive cloud apps. You can play around with a demo of their auto-tagging service here.
You’ll need to create a free developer account with Imagga for this Alamofire tutorial. Imagga requires an authorization header in each HTTP request so only people with an account can use their services. Go to https://imagga.com/auth/signup/hacker and fill out the form. After you create your account, check out the dashboard:
Listed down in the Authorization section is a secret token you’ll use later. You’ll need to include this information with every HTTP request as a header.
Note: Make sure you copy the whole secret token, be sure to scroll over to the right and verify you copied everything.
You’ll be using Imagga’s content endpoint to upload the photos, tagging endpoint for the image recognition and colors endpoint for color identification. You can read all about the Imagga API at http://docs.imagga.com.
If you’re coming to this tutorial with very little experience in using third-party services over the Internet, you might be wondering what all those acronyms mean! :]
HTTP is the application protocol, or set of rules, web sites use to transfer data from the web server to your screen. You’ve seen HTTP (or HTTPS) listed in the front of every URL you type into a web browser. You might have heard of other application protocols, such as FTP, Telnet, and SSH. HTTP defines several request methods, or verbs, the client (your web browser or app) use to indicate the desired action:
REST, or REpresentational State Transfer, is a set of rules for designing consistent, easy-to-use and maintainable web APIs. REST has several architecture rules that enforce things such as not persisting states across requests, making requests cacheable, and providing uniform interfaces. This makes it easy for app developers like you to integrate the API into your app, without needing to track the state of data across requests.
JSON stands for JavaScript Object Notation. It provides a straightforward, human-readable and portable mechanism for transporting data between two systems. JSON has a limited number of data types: string, boolean, array, object/dictionary, null and number. There’s no distinction between integers and decimals.
There are a few native choices for converting your objects in memory to JSON and vice-versa: the good old JSONSerialization class and the newly-added JSONEncoder and JSONDecoder classes. In addition, there are numerous third party libraries that help with handling JSON. You’ll use one of them, SwiftyJSON in this tutorial.
The combination of HTTP, REST and JSON make up a good portion of the web services available to you as a developer. Trying to understand how every little piece works can be overwhelming. Libraries like Alamofire can help reduce the complexity of working with these services, and get you up and running faster than you could without their help.
Why do you need Alamofire at all? Apple already provides URLSession and other classes for downloading content via HTTP, so why complicate things with another third party library?
The short answer is Alamofire is based on URLSession, but it frees you from writing boilerplate code which makes writing networking code much easier. You can access data on the Internet with very little effort, and your code will be much cleaner and easier to read.
There are several major functions available with Alamofire:
Alamofire.upload: Upload files with multipart, stream, file or data methods.Alamofire.download: Download files or resume a download already in progress.Alamofire.request: Every other HTTP request not associated with file transfers.These Alamofire methods are global within Alamofire so you don’t have to instantiate a class to use them. There are underlying pieces to Alamofire that are classes and structs, like SessionManager, DataRequest, and DataResponse; however, you don’t need to fully understand the entire structure of Alamofire to start using it.
Here’s an example of the same networking operation with both Apple’s URLSession and Alamofire’s request function:
// With URLSession
public func fetchAllRooms(completion: @escaping ([RemoteRoom]?) -> Void) {
guard let url = URL(string: "http://localhost:5984/rooms/_all_docs?include_docs=true") else {
completion(nil)
return
}
var urlRequest = URLRequest(url: url,
cachePolicy: .reloadIgnoringLocalAndRemoteCacheData,
timeoutInterval: 10.0 * 1000)
urlRequest.httpMethod = "GET"
urlRequest.addValue("application/json", forHTTPHeaderField: "Accept")
let task = urlSession.dataTask(with: urlRequest)
{ (data, response, error) -> Void in
guard error == nil else {
print("Error while fetching remote rooms: \(String(describing: error)")
completion(nil)
return
}
guard let data = data,
let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
print("Nil data received from fetchAllRooms service")
completion(nil)
return
}
guard let rows = json?["rows"] as? [[String: Any]] else {
print("Malformed data received from fetchAllRooms service")
completion(nil)
return
}
let rooms = rows.flatMap { roomDict in return RemoteRoom(jsonData: roomDict) }
completion(rooms)
}
task.resume()
}
Versus:
// With Alamofire
func fetchAllRooms(completion: @escaping ([RemoteRoom]?) -> Void) {
guard let url = URL(string: "http://localhost:5984/rooms/_all_docs?include_docs=true") else {
completion(nil)
return
}
Alamofire.request(url,
method: .get,
parameters: ["include_docs": "true"])
.validate()
.responseJSON { response in
guard response.result.isSuccess else {
print("Error while fetching remote rooms: \(String(describing: response.result.error)")
completion(nil)
return
}
guard let value = response.result.value as? [String: Any],
let rows = value["rows"] as? [[String: Any]] else {
print("Malformed data received from fetchAllRooms service")
completion(nil)
return
}
let rooms = rows.flatMap { roomDict in return RemoteRoom(jsonData: roomDict) }
completion(rooms)
}
}
You can see the required setup for Alamofire is shorter and it’s much clearer what the function does. You deserialize the response with responseJSON(options:completionHandler:) and calling validate() to verify the response status code is in the default acceptable range between 200 and 299 simplifies error condition handling.
Now the theory is out of the way, it’s time to start using Alamofire.
Open ViewController.swift and add the following to the top, below import SwiftyJSON:
import Alamofire
This lets you use the functionality provided by the Alamofire module in your code, which you’ll be doing soon!
Next, go to imagePickerController(_:didFinishPickingMediaWithInfo:) and add the following to the end, right before the call to dismiss(animated:):
// 1
takePictureButton.isHidden = true
progressView.progress = 0.0
progressView.isHidden = false
activityIndicatorView.startAnimating()
upload(image: image,
progressCompletion: { [weak self] percent in
// 2
self?.progressView.setProgress(percent, animated: true)
},
completion: { [weak self] tags, colors in
// 3
self?.takePictureButton.isHidden = false
self?.progressView.isHidden = true
self?.activityIndicatorView.stopAnimating()
self?.tags = tags
self?.colors = colors
// 4
self?.performSegue(withIdentifier: "ShowResults", sender: self)
})
Everything with Alamofire is asynchronous, which means you’ll update the UI in an asynchronous manner:
Next, find upload(image:progressCompletion:completion:) at the bottom of the file. It is currently only a method stub, so give it the following implementation:
func upload(image: UIImage,
progressCompletion: @escaping (_ percent: Float) -> Void,
completion: @escaping (_ tags: [String]?, _ colors: [PhotoColor]?) -> Void) {
// 1
guard let imageData = UIImageJPEGRepresentation(image, 0.5) else {
print("Could not get JPEG representation of UIImage")
return
}
// 2
Alamofire.upload(multipartFormData: { multipartFormData in
multipartFormData.append(imageData,
withName: "imagefile",
fileName: "image.jpg",
mimeType: "image/jpeg")
},
to: "http://api.imagga.com/v1/content",
headers: ["Authorization": "Basic xxx"],
encodingCompletion: { encodingResult in
})
}
Here’s what’s happening:
Data instance.imageData) into a MIME multipart request to send to the Imagga content endpoint.Basic xxx with the actual authorization header taken from the Imagga dashboard.Next, add the following to the encodingCompletion closure:
switch encodingResult {
case .success(let upload, _, _):
upload.uploadProgress { progress in
progressCompletion(Float(progress.fractionCompleted))
}
upload.validate()
upload.responseJSON { response in
}
case .failure(let encodingError):
print(encodingError)
}
This chunk of code calls the Alamofire upload function and passes in a small calculation to update the progress bar as the file uploads. It then validates the response has a status code in the default acceptable range between 200 and 299.
Note: Prior to Alamofire 4 it was not guaranteed progress callbacks were called on the main queue. Beginning with Alamofire 4, the new progress callback API is always called on the main queue.
Next, add the following code to the upload.responseJSON closure:
// 1
guard response.result.isSuccess,
let value = response.result.value else {
print("Error while uploading file: \(String(describing: response.result.error))")
completion(nil, nil)
return
}
// 2
let firstFileID = JSON(value)["uploaded"][0]["id"].stringValue
print("Content uploaded with ID: \(firstFileID)")
//3
completion(nil, nil)
Here’s a step-by-step explanation of the above code:
firstFileID from the response.Note: Every response has a Result enum with a value and type. Using automatic validation, the result is considered a success when it returns a valid HTTP Code between 200 and 299 and the Content Type is of a valid type specified in the Accept HTTP header field.
You can perform manual validation by adding .validate options as shown below:
Alamofire.request("https://httpbin.org/get", parameters: ["foo": "bar"])
.validate(statusCode: 200..<300)
.validate(contentType: ["application/json"])
.response { response in
// response handling code
}
The UI won't show an error if you hit an error during the upload; it merely returns no tags or colors to the user. This isn't the best user experience, but it's fine for this tutorial.
Build and run your project; select an image and watch the progress bar change as the file uploads. You should see a note like the following in your console when the upload completes:
Congratulations, you've successfully uploaded a file over the Interwebs!
The next step after uploading the image to Imagga is to fetch the tags Imagga produces after it analyzes the photo.
Add the following method to the ViewController extension below upload(image:progress:completion:):
func downloadTags(contentID: String, completion: @escaping ([String]?) -> Void) {
// 1
Alamofire.request("http://api.imagga.com/v1/tagging",
parameters: ["content": contentID],
headers: ["Authorization": "Basic xxx"])
// 2
.responseJSON { response in
guard response.result.isSuccess,
let value = response.result.value else {
print("Error while fetching tags: \(String(describing: response.result.error))")
completion(nil)
return
}
// 3
let tags = JSON(value)["results"][0]["tags"].array?.map { json in
json["tag"].stringValue
}
// 4
completion(tags)
}
}
Here's a step-by-step explanation of the above code:
content with the ID you received after the upload. Again, be sure to replace Basic xxx with your actual authorization header.tags array from the response. Iterate over each dictionary object in the tags array, retrieving the value associated with the tag key.tags received from the service.Next, go back to upload(image:progress:completion:) and replace the call to the completion handler in the success condition with the following:
self.downloadTags(contentID: firstFileID) { tags in
completion(tags, nil)
}
This simply sends along the tags to the completion handler.
Build and run your project; select a photo and you should see something similar to the following appear:
Pretty slick! That Imagga is one smart API. :] Next, you'll fetch the colors of the image.
Add the following method to the ViewController extension below downloadTags(contentID:completion:):
func downloadColors(contentID: String, completion: @escaping ([PhotoColor]?) -> Void) {
// 1.
Alamofire.request("http://api.imagga.com/v1/colors",
parameters: ["content": contentID],
headers: ["Authorization": "Basic xxx"])
.responseJSON { response in
// 2
guard response.result.isSuccess,
let value = response.result.value else {
print("Error while fetching colors: \(String(describing: response.result.error))")
completion(nil)
return
}
// 3
let photoColors = JSON(value)["results"][0]["info"]["image_colors"].array?.map { json in
PhotoColor(red: json["r"].intValue,
green: json["g"].intValue,
blue: json["b"].intValue,
colorName: json["closest_palette_color"].stringValue)
}
// 4
completion(photoColors)
}
}
Taking each numbered comment in turn:
content with the ID you received after the upload. Again, be sure to replace Basic xxx with your actual authorization header.image_colors array from the response. Iterate over each dictionary object in the image_colors array, and transform it into a PhotoColor object. This object pairs colors in the RGB format with the color name as a string.photoColors from the service.Finally, go back to upload(image:progress:completion:) and replace the call to downloadTags(contentID:) in the success condition with the following:
self.downloadTags(contentID: firstFileID) { tags in
self.downloadColors(contentID: firstFileID) { colors in
completion(tags, colors)
}
}
This nests the operations of uploading the image, downloading tags and downloading colors.
Build and run your project again; this time, you should see the returned color tags when you select the Colors button:
This uses the RGB colors you mapped to PhotoColor structs to change the background color of the view. You've now successfully uploaded an image to Imagga and fetched data from two different endpoints. You've come a long way, but there's some room for improvement in how you're using Alamofire in PhotoTagger.
You probably noticed some repeated code in PhotoTagger. If Imagga released v2 of their API and deprecated v1, PhotoTagger would no longer function and you'd have to update the URL in each of the three methods. Similarly, if your authorization token changed you'd be updating it all over the place.
Alamofire provides a simple method to eliminate this code duplication and provide centralized configuration. The technique involves creating a struct conforming to URLRequestConvertible and updating your upload and request calls.
Create a new Swift file by clicking File\New\File... and selecting Swift file under iOS. Click Next, name the file ImaggaRouter.swift, select the Group PhotoTagger with the yellow folder icon and click Create.
Add the following to your new file:
import Alamofire
public enum ImaggaRouter: URLRequestConvertible {
// 1
enum Constants {
static let baseURLPath = "http://api.imagga.com/v1"
static let authenticationToken = "Basic xxx"
}
// 2
case content
case tags(String)
case colors(String)
// 3
var method: HTTPMethod {
switch self {
case .content:
return .post
case .tags, .colors:
return .get
}
}
// 4
var path: String {
switch self {
case .content:
return "/content"
case .tags:
return "/tagging"
case .colors:
return "/colors"
}
}
// 5
var parameters: [String: Any] {
switch self {
case .tags(let contentID):
return ["content": contentID]
case .colors(let contentID):
return ["content": contentID, "extract_object_colors": 0]
default:
return [:]
}
}
// 6
public func asURLRequest() throws -> URLRequest {
let url = try Constants.baseURLPath.asURL()
var request = URLRequest(url: url.appendingPathComponent(path))
request.httpMethod = method.rawValue
request.setValue(Constants.authenticationToken, forHTTPHeaderField: "Authorization")
request.timeoutInterval = TimeInterval(10 * 1000)
return try URLEncoding.default.encode(request, with: parameters)
}
}
Here's a step-by-step explanation of the above code:
Basic xxx with your actual authorization header.HTTP method for each api endpoint.path for each api endpoint.parameters for each api endpoint.URLRequest for the requested endpoint.Now all your boilerplate code is in single place, should you ever need to update it.
Go back to ViewController.swift and in upload(image:progress:completion:) replace:
Alamofire.upload(
multipartFormData: { multipartFormData in
multipartFormData.append(imageData,
withName: "imagefile",
fileName: "image.jpg",
mimeType: "image/jpeg")
},
to: "http://api.imagga.com/v1/content",
headers: ["Authorization": "Basic xxx"],
with the following:
Alamofire.upload(multipartFormData: { multipartFormData in
multipartFormData.append(imageData,
withName: "imagefile",
fileName: "image.jpg",
mimeType: "image/jpeg")
},
with: ImaggaRouter.content,
Next replace the call for Alamofire.request in downloadTags(contentID:completion:) with:
Alamofire.request(ImaggaRouter.tags(contentID))
Finally, update the call to Alamofire.request in downloadColors(contentID:completion:) with:
Alamofire.request(ImaggaRouter.colors(contentID))
responseJSON handlers in place for both of the previous edits.Build and run for the final time; everything should function just as before, which means you've refactored everything without breaking your app. However, you don't have to go through your entire source code if anything on the Imagga integration ever changes: APIs, your authorization token, parameters, etc. Awesome job!
You can download the completed version of the project using the Download Materials button at the top or bottom of this tutorial. Don't forget to replace your authorization token as appropriate!
This tutorial covered the very basics. You can take a deeper dive by looking at the documentation on the Alamofire site at https://github.com/Alamofire/Alamofire.
Also, you can take some time to learn more about Apple's URLSession which Alamofire uses under the hood:
Please share any comments or questions about this tutorial in the forum discussion below!
The post Alamofire Tutorial: Getting Started appeared first on Ray Wenderlich.
Salina ist bestimmt die grünste der sieben Äolischen In
Der Beitrag Salina, die grüne Perle der Äolen erschien zuerst auf SegelnBlogs.
If you're sick of waiting for the progress bar to complete every time you reboot after a macOS software update, then you'll be pleased to learn there's another way to update your Mac that could potentially reduce your downtime.
We are pleased to announce a new video series “Introduction to UniFi” is available on the UBNT YouTube channel.
