Non catégorisé

The Nightmare-Eclipse Disclosure Conflict: Timeline and Context

User Rating: 5 / 5

Details

Created: Sunday, 31 May 2026 10:20

Written by LGHM / Fabien @ Consultingit.fr

The Nightmare-Eclipse Disclosure Conflict: Timeline and Context

## Overview

The Nightmare-Eclipse situation became a fast-moving disclosure dispute that pulled Microsoft, multiple security researchers, and the broader vulnerability community into the same widening conflict. What began as a set of public technical drops quickly turned into a dispute over trust, process, retaliation, and the limits of coordinated disclosure.

This timeline follows the public record from late March through June 1, 2026. It focuses on the sequence of disclosures, the reactions from Microsoft, the escalation across platforms, and the way the controversy spread beyond the original technical issues.

## March 26, 2026: The first public post

The earliest public post associated with Nightmare-Eclipse appeared on March 26, 2026, under the blunt title “I never wanted to do this.” The author reopened a blog and created a fresh GitHub account specifically to publish code, framing the move as forced rather than voluntary.

The tone of the post was openly hostile and carried a strong sense of grievance. It suggested that some prior agreement had been broken, leaving the author with no meaningful alternative. That framing matters because it places the origin of the conflict before the technical disclosures themselves.

From the start, the dispute looked less like a routine vulnerability report and more like the breakdown of a relationship. The post implied that one side had crossed a line, and that the disclosures were a response to that breach.

## April 2, 2026: Verification and first disclosure

On April 2, two important posts appeared. First, a public PGP key was released so that future posts and files could be authenticated. That step signaled that the author intended to publish material that should be verifiable as coming directly from them.

Later the same day came the first real disclosure: “Public disclosure” tied to BlueHammer. The post linked to a GitHub repository and presented the release as a direct challenge to Microsoft. The wording was deliberately confrontational, including a sarcastic reference to Microsoft Security Response Center leadership.

This was the moment the situation moved from grievance to active disclosure. The PGP key gave the posts a layer of authenticity, but it also gave the entire campaign a more formal and persistent structure.

## April 12, 2026: UnDefend appears

A second tool, called “Funny DOS tool” and associated with UnDefend, was published on April 12 in another signed post. The author described it as a “0day (kinda)” and claimed Microsoft would eventually mitigate it, but only as a lower priority.

The post argued that the machine could be turned into “basically a hole” because anyone with administrator privileges could run arbitrary code, while Windows Defender would not be able to do much about it. The message was clear: the tool was presented as a practical defensive bypass rather than a theoretical proof.

The release reinforced the author’s willingness to publish multiple tools in rapid succession. By this stage, the disclosures were no longer isolated incidents but part of a sustained pattern.

## April 15, 2026: RedSun and the response to CVE-2026-33825

On April 15, Nightmare-Eclipse published another signed post titled “Public disclosure, a response for CVE-2026-33825 patch,” which introduced the RedSun repository. Much of the post directly attacked Microsoft’s response to BlueHammer and rejected what the author saw as generic dismissal.

The post also repeated a set of serious accusations about how Microsoft had handled prior contact. It claimed a case had been filed and dismissed, and alleged that the author had been told their life would be ruined. The message painted Microsoft not as a neutral recipient of reports, but as an institution that actively punishes researchers.

The post ended with a threat to keep escalating by publishing more severe issues. That shifted the conflict further away from disclosure and toward open confrontation.

## April 25, 2026: The dead man’s switch

A signed post titled “Remember this…” appeared on April 25 and changed the tone of the situation again. The author introduced the idea of a dead man’s switch, warning that if Microsoft continued along a certain path, a pre-armed release would activate automatically.

The post claimed the switch had already been active before the current dispute began. It also suggested that the material would be difficult and time-consuming to patch, and that it had been placed somewhere other than the author’s physical location.

This was more than posturing. It reframed the conflict as one of leverage, where the mere possibility of release was meant to influence Microsoft’s behavior.

## May 12–15, 2026: YellowKey, GreenPlasma, and MiniPlasma

By May 12, the situation had escalated again with “Two more public disclosures,” introducing YellowKey and GreenPlasma. The author claimed Defender had been intentionally spared during this release, while also warning that Microsoft would clamp down if a specific component was attacked too often.

The next day, the author posted a note about Microsoft silently patching RedSun without issuing a CVE or public advisory. That silence was treated as unacceptable, especially if the vulnerability had been under active exploitation. The same post also discussed YellowKey and claimed that TPM plus PIN protection would not stop it, although proof for that was being withheld.

On May 14, the author relayed findings from other researchers about YellowKey and GreenPlasma. YellowKey was said to involve a binary named autofstx.exe, while GreenPlasma was described as a technique involving writes to a protected registry key on patched Windows systems. The post acknowledged that not every claim had been independently verified.

On May 15, another signed post introduced MiniPlasma, described as a powerful local privilege escalation. The author said they found it by accident and claimed it worked on fully patched Windows 11 and Windows Server 2025, producing a SYSTEM shell. This connected directly to the earlier discussion of an old CVE-2020-17103 path that appeared to remain relevant.

## May 17, 2026 : NSA backdoor

A critical, unpatched Windows 11 BitLocker zero-day named "YellowKey" has been leaked online. It is believed to be an NSA/TAO backdoor.

Released by researcher Nightmare-Eclipse, the exploit allows anyone with physical access to bypass default TPM-only encryption via a USB drive. By targeting an obscure "FsTx" framework hidden inside the Windows Recovery Environment (WinRE), attackers gain full read/write drive access. Microsoft has no patch yet. Defenders should immediately run reagentc /disable in CMD to kill WinRE.

https://x.com/officialrnintel/status/2055811768027427195

## May 20, 2026: CVE-2026-45585 and the wiped MSRC account

Microsoft’s advisory for CVE-2026-45585 prompted a new response on May 20. In “Dear Microsoft,” Nightmare-Eclipse objected to Microsoft’s claim that the public release violated coordinated vulnerability best practices.

The post argued that this language damaged the author’s personal reputation and did not resolve the underlying conflict. It also introduced a new allegation: that Microsoft had revoked and completely wiped the MSRC account used to report vulnerabilities. According to the author, repeated requests for clarification had gone unanswered.

This was a key turning point because it linked a specific Microsoft advisory to the account action. The dispute was no longer just about disclosure style; it was also about access, identity, and retaliation.

## May 23–26, 2026: The deadline and the bans

On May 23, Nightmare-Eclipse published “July 14th,” which read like an ultimatum. The post accused Microsoft of refusing to communicate, of defaming the author through the CVE-2026-45585 advisory, and of flagging and wiping the GitHub account.

The author declared that July 14 would matter and implied that something serious would happen then. They also announced a move to GitLab and mapped specific CVEs to project names, identifying CVE-2026-45498 as UnDefend and CVE-2026-41091 as RedSun.

The GitHub account was removed on May 24, and the public reaction was immediate. For many observers, the ban became a symbolic moment, and some interpreted it as a move that increased sympathy for the researcher rather than reducing risk.

Three days later, on May 26, the GitLab account was also banned. That left the author without access to the two major code-hosting platforms they had just used, and it intensified uncertainty about where any future release would land.

## May 27–29, 2026: Microsoft responds, then Bitskrieg appears

On May 27, Microsoft published an official response titled “A shared responsibility: Protecting customers through Coordinated Vulnerability Disclosure.” The post said several zero-days had been publicly disclosed without first being shared with Microsoft, and it named the project set directly: RedSun, UnDefend, BlueHammer, YellowKey, GreenPlasma, and MiniPlasma.

Microsoft framed coordinated disclosure as the expected industry norm and warned that its Digital Crimes Unit would continue pursuing cases against actors and enablers of criminal activity. At the same time, the company said it still welcomed future submissions, even from researchers with prior disputes or reputations.

On May 28, Nightmare-Eclipse posted only the number 7 above an image of Albert Wesker. The post contained no signature or explanation, which made it stand out sharply from the earlier long, formal disclosures.

The next day, “Announcing Bitskrieg” appeared. The post said several researchers had contributed vulnerabilities, credited JonasLyk with most of the work, and claimed the group had found a way to violate Secure Boot trust. The author was careful to say it was not a full Secure Boot bypass, but they also claimed it fully bypassed BitLocker and could possibly affect confidential VMs.

Bitskrieg marked a major expansion in scope. The conflict now looked less like a single researcher versus Microsoft and more like a broader, semi-coordinated security campaign with visible outside support.

## May 30–31, 2026: Broader community fallout

By May 30, the controversy had spread well beyond the original posts. It was circulating across Reddit, X, cybersecurity blogs, reverse-engineering communities, and international security circles.

The discussion increasingly moved away from the vulnerabilities themselves and toward the larger process questions. People were debating whether coordinated disclosure was functioning properly, how researchers should be treated, and whether Microsoft’s response had escalated the situation unnecessarily.

By May 31, the situation was still unresolved. Bitskrieg had not yet been released, but it remained expected during June. The community was watching closely, and the tone of the discussion had become polarized.

That same day, criticism of supporters started to surface as well. Some observers dismissed the whole episode as theatrical, while others defended the disclosures and argued that tone should not obscure the underlying technical claims.

## June 1, 2026: Microsoft softens its position

In the early hours of June 1, Microsoft Security Response Center posted a second public statement on X. Compared with the earlier blog post, the tone was noticeably softer and more measured.

The statement said Microsoft had no intention of pursuing action against individuals conducting or publishing security research. It drew a distinction between research and criminal activity, saying law enforcement would only be involved where someone broke the law and caused real harm.

Microsoft also acknowledged that some interactions had fallen short and said it was working to learn from them. The company pointed to the growing volume of reports and the rise of AI-assisted research, while also emphasizing that many on the team had security research backgrounds themselves.

For many readers, this sounded like a partial reset. It did not resolve the controversy, but it did step back from the more aggressive posture that had fueled so much of the backlash.

## June 9, 2026:Nightmare Eclipse just dropped RoguePlanet, a new Windows Defender local privilege escalation 0day PoC.

NE suspects the BitLocker bypass may still work but isn't certain.

He has a new GitHub btw, let's see how long the account will last: https://github.com/MSNightmare/RoguePlanet

https://x.com/IntCyberDigest/status/2064467119400526027

## What this means

The Nightmare-Eclipse conflict is no longer just a sequence of disclosures. It has become a case study in how quickly vulnerability handling, public messaging, and platform enforcement can turn a technical issue into a broader legitimacy crisis.

For cybersecurity researchers, the core lesson is not only about the bugs themselves. It is also about how trust can collapse when disclosure channels fail, how public threats can reshape incentives, and how platform bans can intensify rather than contain conflict. The situation still appears active, and the expected June release of Bitskrieg remains one of the most closely watched developments.

need help?

Fill out this form

[No form id or name provided!]

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model

User Rating: 5 / 5

Details

Created: Sunday, 07 September 2025 23:57

Written by Azure.AI.Vision.ImageAnalysis@consultingit.fr

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: Why this article?

Because when i'm visiting a place i post modified and computer generated pictures on social media networks and people send me messages to ask me which tool i use to do that. I'm so tired of explaining every time that there is no magic, and there's no Harry Potter with me, so that I decided to create this article to explain. Anyone can do the same thing as long as they know a little bit about software development. Lets'go!

Instead of the original "ghibli" filter, I applied the "Pixar" filter to my selfie in front of the entrance to the Big Data and AI fair in Paris.

Two other articles explain the computer vision (Azure AI Vision SDK for image analysis explained with Github Copilot) and the computer generated description of the scene (AI Azure Open AI Chatbot Integration with RAG CosmosDB from fork GIT POC MVP).

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: project summary

Create a local directory with a python app. Test locally the python app with CURL. Test locally with Streamlit.  Upload this directory to Github.  Create an Azure web app service. Deploy this Github directory to Azure Web app using a Github Action workflow.

This guide describes how to replicate image editing (adding a "Ghibli studio" filter to a selfie) using Azure services. It covers local preparation, Python code for inpainting via the Azure OpenAI API, transformation into a Streamlit web app, and then deployment to Azure App Service with a GitHub Actions pipeline.

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: architecture and tools

Architecture and Tools
• Azure OpenAI (testing with DALL•E 3, GPT-image-1,Flux1 kontext pro models) for inpainting.
• Streamlit for the web interface.
• Azure App Service for application hosting.
• GitHub + GitHub Actions for CI/CD and automatic deployment.
• Python with libraries: requests, pillow, base64...
• Local tools: az CLI for manual deployment if necessary.

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: Preparation and Prerequisites

• Azure account with access to Azure OpenAI and a deployed resource.
• Azure OpenAI API key.
• GitHub account.
• Local Python 3.10+ environment.
• Install local dependencies: pip install streamlit requests pillow
• Environment variables to configure in production (App Service):
o API_KEY: Azure OpenAI key
o AZURE_ENDPOINT and DEPLOYMENT_NAME if necessary

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: installing python from the window store

python -m venv .venv

.\.venv\Scripts\activate

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: Inpainting python code

First version of the python code:

python

import os

import requests

import base64

from PIL import Image

from io import BytesIO

# === CONFIGURATION ===

AZURE_ENDPOINT = os.getenv("AZURE_ENDPOINT", "https://<MY-RESSOURCE>.openai.azure.com")

DEPLOYMENT_NAME = os.getenv("DEPLOYMENT_NAME", "<MY-DEPLOYMENT>")

API_KEY = os.getenv("API_KEY", "<My API KEY>")

API_VERSION = "2025-04-01-preview"

# === TOOLS ===

def load_image_as_base64(path):

    with open(path, "rb") as f:

        return base64.b64encode(f.read()).decode("utf-8")

def image_to_pil_from_b64(b64):

    data = base64.b64decode(b64)

    return Image.open(BytesIO(data))

def pil_to_base64(image, fmt="PNG"):

    buf = BytesIO()

    image.save(buf, format=fmt)

    return base64.b64encode(buf.getvalue()).decode("utf-8")

def create_mask_image(size, box):

    mask = Image.new("L", size, 0)

    draw = Image.new("L", size, 0)

    mask.paste(255, box)

    return pil_to_base64(mask, fmt="PNG")

# === API CALL ===

def edit_image(image_b64, mask_b64, prompt):

    url = f"{AZURE_ENDPOINT}/openai/deployments/{DEPLOYMENT_NAME}/images/edits?api-version={API_VERSION}"

    headers = {

        "Content-Type": "application/json",

        "api-key": API_KEY

    }

    payload = {

        "image": image_b64,

        "mask": mask_b64,

        "prompt": prompt,

        "model": "gpt-image-1",

        "size": "1024x1024",

        "n": 1,

        "quality": "high"

    }

    r = requests.post(url, headers=headers, json=payload)

    r.raise_for_status()

    data = r.json()

    return data["data"][0]["image"]

# === EXEMPLE D'UTILISATION ===

if __name__ == "__main__":

    image_path = "Original picture.jpg"

    image_b64 = load_image_as_base64(image_path)

    # Exemple de box : (x1, y1, x2, y2) sur image 1024x1024

    mask_b64 = create_mask_image((1024, 1024), (100, 300, 300, 600))

    prompt = "Apply a ghibli style to the picture"

    result_b64 = edit_image(image_b64, mask_b64, prompt)

    result_img = image_to_pil_from_b64(result_b64)

    result_img.save("Ghibli_edited.png")

    print("Image saved to Ghibli_edited.png")

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: installing streamlit requests pillow

pip install streamlit

(.venv) C:\Users\loicb\Documents\ghibli-style-app>pip install streamlit

Collecting streamlit

  Downloading streamlit-1.50.0-py3-none-any.whl (10.1 MB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 10.1/10.1 MB 2.5 MB/s eta 0:00:00

Collecting altair!=5.4.0,!=5.4.1,<6,>=4.0

  Downloading altair-5.5.0-py3-none-any.whl (731 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 731.2/731.2 kB 2.6 MB/s eta 0:00:00

Collecting blinker<2,>=1.5.0

  Downloading blinker-1.9.0-py3-none-any.whl (8.5 kB)

Collecting cachetools<7,>=4.0

  Downloading cachetools-6.2.0-py3-none-any.whl (11 kB)

Collecting tenacity<10,>=8.1.0

  Downloading tenacity-9.1.2-py3-none-any.whl (28 kB)

Collecting click<9,>=7.0

  Downloading click-8.3.0-py3-none-any.whl (107 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 107.3/107.3 kB 1.5 MB/s eta 0:00:00

Collecting pillow<12,>=7.1.0

  Downloading pillow-11.3.0-cp310-cp310-win_amd64.whl (7.0 MB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 7.0/7.0 MB 2.3 MB/s eta 0:00:00

Collecting gitpython!=3.1.19,<4,>=3.0.7

  Downloading gitpython-3.1.45-py3-none-any.whl (208 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 208.2/208.2 kB 2.1 MB/s eta 0:00:00

Collecting toml<2,>=0.10.1

  Downloading toml-0.10.2-py2.py3-none-any.whl (16 kB)

Collecting protobuf<7,>=3.20

  Downloading protobuf-6.32.1-cp310-abi3-win_amd64.whl (435 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 435.7/435.7 kB 1.8 MB/s eta 0:00:00

Collecting watchdog<7,>=2.1.5

  Downloading watchdog-6.0.0-py3-none-win_amd64.whl (79 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 79.1/79.1 kB 2.2 MB/s eta 0:00:00

Collecting typing-extensions<5,>=4.4.0

  Downloading typing_extensions-4.15.0-py3-none-any.whl (44 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 44.6/44.6 kB 2.3 MB/s eta 0:00:00

Collecting pandas<3,>=1.4.0

  Downloading pandas-2.3.2-cp310-cp310-win_amd64.whl (11.3 MB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 11.3/11.3 MB 1.8 MB/s eta 0:00:00

Collecting pydeck<1,>=0.8.0b4

  Downloading pydeck-0.9.1-py2.py3-none-any.whl (6.9 MB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 6.9/6.9 MB 2.5 MB/s eta 0:00:00

Collecting packaging<26,>=20

  Downloading packaging-25.0-py3-none-any.whl (66 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 66.5/66.5 kB 1.8 MB/s eta 0:00:00

Collecting requests<3,>=2.27

  Downloading requests-2.32.5-py3-none-any.whl (64 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 64.7/64.7 kB 3.4 MB/s eta 0:00:00

Collecting numpy<3,>=1.23

  Downloading numpy-2.2.6-cp310-cp310-win_amd64.whl (12.9 MB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 12.9/12.9 MB 2.3 MB/s eta 0:00:00

Collecting pyarrow>=7.0

  Downloading pyarrow-21.0.0-cp310-cp310-win_amd64.whl (26.2 MB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 26.2/26.2 MB 2.3 MB/s eta 0:00:00

Collecting tornado!=6.5.0,<7,>=6.0.3

  Downloading tornado-6.5.2-cp39-abi3-win_amd64.whl (445 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 445.4/445.4 kB 2.0 MB/s eta 0:00:00

Collecting narwhals>=1.14.2

  Downloading narwhals-2.6.0-py3-none-any.whl (408 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 408.4/408.4 kB 2.5 MB/s eta 0:00:00

Collecting jinja2

  Downloading jinja2-3.1.6-py3-none-any.whl (134 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 134.9/134.9 kB 1.6 MB/s eta 0:00:00

Collecting jsonschema>=3.0

  Downloading jsonschema-4.25.1-py3-none-any.whl (90 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 90.0/90.0 kB 2.5 MB/s eta 0:00:00

Collecting colorama

  Downloading colorama-0.4.6-py2.py3-none-any.whl (25 kB)

Collecting gitdb<5,>=4.0.1

  Downloading gitdb-4.0.12-py3-none-any.whl (62 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 62.8/62.8 kB 1.7 MB/s eta 0:00:00

Collecting tzdata>=2022.7

  Downloading tzdata-2025.2-py2.py3-none-any.whl (347 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 347.8/347.8 kB 1.5 MB/s eta 0:00:00

Collecting pytz>=2020.1

  Downloading pytz-2025.2-py2.py3-none-any.whl (509 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 509.2/509.2 kB 2.1 MB/s eta 0:00:00

Collecting python-dateutil>=2.8.2

  Downloading python_dateutil-2.9.0.post0-py2.py3-none-any.whl (229 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 229.9/229.9 kB 2.0 MB/s eta 0:00:00

Collecting idna<4,>=2.5

  Downloading idna-3.10-py3-none-any.whl (70 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 70.4/70.4 kB 1.9 MB/s eta 0:00:00

Collecting charset_normalizer<4,>=2

  Downloading charset_normalizer-3.4.3-cp310-cp310-win_amd64.whl (107 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 107.5/107.5 kB 1.6 MB/s eta 0:00:00

Collecting certifi>=2017.4.17

  Downloading certifi-2025.8.3-py3-none-any.whl (161 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 161.2/161.2 kB 2.4 MB/s eta 0:00:00

Collecting urllib3<3,>=1.21.1

  Downloading urllib3-2.5.0-py3-none-any.whl (129 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 129.8/129.8 kB 1.9 MB/s eta 0:00:00

Collecting smmap<6,>=3.0.1

  Downloading smmap-5.0.2-py3-none-any.whl (24 kB)

Collecting MarkupSafe>=2.0

  Downloading markupsafe-3.0.3-cp310-cp310-win_amd64.whl (15 kB)

Collecting referencing>=0.28.4

  Downloading referencing-0.36.2-py3-none-any.whl (26 kB)

Collecting rpds-py>=0.7.1

  Downloading rpds_py-0.27.1-cp310-cp310-win_amd64.whl (228 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 228.4/228.4 kB 2.3 MB/s eta 0:00:00

Collecting attrs>=22.2.0

  Downloading attrs-25.3.0-py3-none-any.whl (63 kB)

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 63.8/63.8 kB 1.1 MB/s eta 0:00:00

Collecting jsonschema-specifications>=2023.03.6

  Downloading jsonschema_specifications-2025.9.1-py3-none-any.whl (18 kB)

Collecting six>=1.5

  Downloading six-1.17.0-py2.py3-none-any.whl (11 kB)

Installing collected packages: pytz, watchdog, urllib3, tzdata, typing-extensions, tornado, toml, tenacity, smmap, six, rpds-py, pyarrow, protobuf, pillow, packaging, numpy, narwhals, MarkupSafe, idna, colorama, charset_normalizer, certifi, cachetools, blinker, attrs, requests, referencing, python-dateutil, jinja2, gitdb, click, pydeck, pandas, jsonschema-specifications, gitpython, jsonschema, altair, streamlit

Successfully installed MarkupSafe-3.0.3 altair-5.5.0 attrs-25.3.0 blinker-1.9.0 cachetools-6.2.0 certifi-2025.8.3 charset_normalizer-3.4.3 click-8.3.0 colorama-0.4.6 gitdb-4.0.12 gitpython-3.1.45 idna-3.10 jinja2-3.1.6 jsonschema-4.25.1 jsonschema-specifications-2025.9.1 narwhals-2.6.0 numpy-2.2.6 packaging-25.0 pandas-2.3.2 pillow-11.3.0 protobuf-6.32.1 pyarrow-21.0.0 pydeck-0.9.1 python-dateutil-2.9.0.post0 pytz-2025.2 referencing-0.36.2 requests-2.32.5 rpds-py-0.27.1 six-1.17.0 smmap-5.0.2 streamlit-1.50.0 tenacity-9.1.2 toml-0.10.2 tornado-6.5.2 typing-extensions-4.15.0 tzdata-2025.2 urllib3-2.5.0 watchdog-6.0.0

(.venv) C:\Users\loicb\Documents\ghibli-style-app>pip install requests pillow

Requirement already satisfied: requests in c:\users\loicb\documents\ghibli-style-app\.venv\lib\site-packages (2.32.5)

Requirement already satisfied: pillow in c:\users\loicb\documents\ghibli-style-app\.venv\lib\site-packages (11.3.0)

Requirement already satisfied: certifi>=2017.4.17 in c:\users\loicb\documents\ghibli-style-app\.venv\lib\site-packages (from requests) (2025.8.3)

Requirement already satisfied: urllib3<3,>=1.21.1 in c:\users\loicb\documents\ghibli-style-app\.venv\lib\site-packages (from requests) (2.5.0)

Requirement already satisfied: idna<4,>=2.5 in c:\users\loicb\documents\ghibli-style-app\.venv\lib\site-packages (from requests) (3.10)

Requirement already satisfied: charset_normalizer<4,>=2 in c:\users\loicb\documents\ghibli-style-app\.venv\lib\site-packages (from requests) (3.4.3)

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit

This second version of the code allows me to upload an picture, send the request to apply the filter and display the result.

python

import os

import streamlit as st

import base64

import requests

from PIL import Image, ImageDraw

from io import BytesIO

# === AZURE via ENV ===

AZURE_ENDPOINT = os.getenv("AZURE_ENDPOINT", "https://<RESSOURCE>.openai.azure.com")

DEPLOYMENT_NAME = os.getenv("DEPLOYMENT_NAME", "<MY_DEPLOYMENT_NAME >")

API_KEY = os.getenv("API_KEY", "")

API_VERSION = "2025-04-01-preview"

# === Tools ===

def pil_to_base64(img, fmt="PNG"):

    buf = BytesIO()

    img.save(buf, format=fmt)

    return base64.b64encode(buf.getvalue()).decode("utf-8")

def base64_to_pil(b64):

    return Image.open(BytesIO(base64.b64decode(b64)))

def create_mask(size, box):

    mask = Image.new("L", size, 0)

    draw = ImageDraw.Draw(mask)

    draw.rectangle(box, fill=255)

    return pil_to_base64(mask, fmt="PNG")

def call_edit_api(image_b64, mask_b64, prompt):

    url = f"{AZURE_ENDPOINT}/openai/deployments/{DEPLOYMENT_NAME}/images/edits?api-version={API_VERSION}"

    headers = {"Content-Type": "application/json", "api-key": API_KEY}

    payload = {

        "image": image_b64,

        "mask": mask_b64,

        "prompt": prompt,

        "model": "gpt-image-1",

        "size": "1024x1024",

        "n": 1,

        "quality": "high"

    }

    resp = requests.post(url, headers=headers, json=payload)

    resp.raise_for_status()

    return resp.json()["data"][0]["image"]

# === STREAMLIT UI ===

st.set_page_config(page_title="Ghibli filter", layout="wide")

st.title("🖼️ Retouche IA avec Azure OpenAI")

uploaded = st.file_uploader("Charge ton image (jpg/png)", type=["jpg","jpeg","png"])

prompt = st.text_area("Prompt", "Apply a ghibli studio style filter on the  image")

col1, col2 = st.columns(2)

if uploaded:

    img = Image.open(uploaded).convert("RGB")

    img = img.resize((1024, 1024))

    col1.image(img, caption="original picture", use_column_width=True)

    x1 = st.slider("X début", 0, 1024, 100)

    y1 = st.slider("Y début", 0, 1024, 300)

    x2 = st.slider("X fin", 0, 1024, 300)

    y2 = st.slider("Y fin", 0, 1024, 600)

    if st.button("Generate modified image"):

        image_b64 = pil_to_base64(img, fmt="PNG")

        mask_b64 = create_mask((1024, 1024), (x1, y1, x2, y2))

        with st.spinner("Generating please wait..."):

            try:

                result_b64 = call_edit_api(image_b64, mask_b64, prompt)

                result_img = base64_to_pil(result_b64)

                col2.image(result_img, caption="Image generated", use_column_width=True)

                buf = BytesIO()

                result_img.save(buf, format="PNG")

                st.download_button("Download image", data=buf.getvalue(), file_name="Ghibli_edited.png", mime="image/png")

            except Exception as e:

                st.error(f"Error : {e}")

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : testing streamlit

(.venv) C:\Users\loicb\Documents\ghibli-style-app>streamlit run app.py

      Welcome to Streamlit!

      If you'd like to receive helpful onboarding emails, news, offers, promotions,

      and the occasional swag, please enter your email address below. Otherwise,

      leave this field blank.

      Email:  XXXXXXXXXXXXXX

  You can find our privacy policy at https://streamlit.io/privacy-policy

  Summary:

  - This open source library collects usage statistics.

  - We cannot see and do not store information contained inside Streamlit apps,

    such as text, charts, images, etc.

  - Telemetry data is stored in servers in the United States.

  - If you'd like to opt out, add the following to %userprofile%/.streamlit/config.toml,

    creating that file if necessary:

    [browser]

    gatherUsageStats = false

  You can now view your Streamlit app in your browser.

  Local URL: http://localhost:8501

  Network URL: http://192.168.0.16:8501

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : choice of the AI model



FLUX.1-Kontext-pro

PRÉVERSION

Aide

Utiliser ce modèle

Fine-tune

Détails

Licence

Generate and edit images through both text and image prompts. Flux.1 Kontext is a multimodal flow matching model that enables both text-to-image generation and in-context image editing. Modify images while maintaining character consistency and performing local edits up to 8x faster than other leading models.

Model developer: Black Forest Labs

Supported languages: English

Model Release Date: June 30, 2025

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : project tree

ghibli-app/

├── app.py

├── edit_image.py

├── requirements.txt

├── startup.sh

├── README.md

└── .github/

    └── workflows/

        └── azure-deploy.yml

• requirements.txt :

Code

streamlit

requests

pillow

• startup.sh :

bash

#!/bin/bash

streamlit run app.py --server.port=$PORT --server.address=0.0.0.0

 startup.sh must be executable (chmod +x startup.sh).

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : code in visual studio code

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : local testing ok

The first local version of the application works like a charm, using a test image:

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : code upload to the github

What is github ? See here (Git & Github for beginners) and here (Utiliser Git et GitHub)

Exemple of synchronysation between git local and github:

C:\Users\loicb\Documents\ghibli-style-app>git pull origin main --rebase

remote: Enumerating objects: 6, done.

remote: Counting objects: 100% (6/6), done.

remote: Compressing objects: 100% (4/4), done.

remote: Total 5 (delta 1), reused 0 (delta 0), pack-reused 0 (from 0)

Unpacking objects: 100% (5/5), 1.25 KiB | 26.00 KiB/s, done.

From https://github.com/cpltproject/ghibli-style-app

 * branch            main       -> FETCH_HEAD

   24cc278..d921a11  main       -> origin/main

Successfully rebased and updated refs/heads/main.

C:\Users\loicb\Documents\ghibli-style-app>git push origin main

Enumerating objects: 11, done.

Counting objects: 100% (11/11), done.

Delta compression using up to 4 threads

Compressing objects: 100% (6/6), done.

Writing objects: 100% (7/7), 1.32 KiB | 270.00 KiB/s, done.

Total 7 (delta 4), reused 0 (delta 0), pack-reused 0 (from 0)

remote: Resolving deltas: 100% (4/4), completed with 3 local objects.

To https://github.com/cpltproject/ghibli-style-app.git

   d921a11..84b7fa8  main -> main

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : deployment to Azure with github action

az webapp deployment list-publishing-profiles --name ghibli-style-app --resource-group ghibli-style-app_group --output tsv

az webapp deployment list-publishing-profiles --name ghibli-style-app --resource-group ghibli-style-app_group --output tsv

REDACTED        https://portal.azure.com        None    https://ghibli-style-app-csbqbeefd3aueqgb.francecentral-01.azurewebsites.net            ghibli-style-app                ghibli-style-app - Web Deploy   MSDeploy        ghibli-style-app-csbqbeefd3aueqgb.scm.francecentral-01.azurewebsites.net:443    REDACTED        REDACTED        WebSites

REDACTED        https://portal.azure.com        None    https://ghibli-style-app-csbqbeefd3aueqgb.francecentral-01.azurewebsites.net    True                    ghibli-style-app - FTP  FTP     ftps://waws-prod-par-043.ftp.azurewebsites.windows.net/site/wwwroot     REDACTED        REDACTED        WebSites

REDACTED        https://portal.azure.com        None    https://ghibli-style-app-csbqbeefd3aueqgb.francecentral-01.azurewebsites.net                    ghibli-style-app - Zip Deploy   ZipDeploy       ghibli-style-app-csbqbeefd3aueqgb.scm.francecentral-01.azurewebsites.net:443    REDACTED        REDACTED        WebSites

az webapp deployment list-publishing-profiles \

  --name ghibli-style-app \

  --resource-group ghibli-style-app_group \

  --output xml

az webapp deployment list-publishing-profiles --name ghibli-style-app --resource-group ghibli-style-app_group –output xml

az webapp deployment list-publishing-profiles \

  --name ghibli-style-app \

  --resource-group ghibli-style-app_group \

  --output xml

az webapp deployment list-publishing-profiles --name ghibli-style-app --resource-group ghibli-style-app_group --output json

C:\Users\loicb>az webapp deployment list-publishing-profiles --name ghibli-style-app --resource-group ghibli-style-app_group --output json

[

  {

    "SQLServerDBConnectionString": "REDACTED",

    "controlPanelLink": "https://portal.azure.com",

    "databases": null,

    "destinationAppUrl": "https://ghibli-style-app-csbqbeefd3aueqgb.francecentral-01.azurewebsites.net",

    "hostingProviderForumLink": "",

    "msdeploySite": "ghibli-style-app",

    "mySQLDBConnectionString": "",

    "profileName": "ghibli-style-app - Web Deploy",

    "publishMethod": "MSDeploy",

    "publishUrl": "ghibli-style-app-csbqbeefd3aueqgb.scm.francecentral-01.azurewebsites.net:443",

    "userName": "REDACTED",

    "userPWD": "REDACTED",

    "webSystem": "WebSites"

  },

  {

    "SQLServerDBConnectionString": "REDACTED",

    "controlPanelLink": "https://portal.azure.com",

    "databases": null,

    "destinationAppUrl": "https://ghibli-style-app-csbqbeefd3aueqgb.francecentral-01.azurewebsites.net",

    "ftpPassiveMode": "True",

    "hostingProviderForumLink": "",

    "mySQLDBConnectionString": "",

    "profileName": "ghibli-style-app - FTP",

    "publishMethod": "FTP",

    "publishUrl": "ftps://waws-prod-par-043.ftp.azurewebsites.windows.net/site/wwwroot",

    "userName": "REDACTED",

    "userPWD": "REDACTED",

    "webSystem": "WebSites"

  },

  {

    "SQLServerDBConnectionString": "REDACTED",

    "controlPanelLink": "https://portal.azure.com",

    "databases": null,

    "destinationAppUrl": "https://ghibli-style-app-csbqbeefd3aueqgb.francecentral-01.azurewebsites.net",

    "hostingProviderForumLink": "",

    "mySQLDBConnectionString": "",

    "profileName": "ghibli-style-app - Zip Deploy",

    "publishMethod": "ZipDeploy",

    "publishUrl": "ghibli-style-app-csbqbeefd3aueqgb.scm.francecentral-01.azurewebsites.net:443",

    "userName": "REDACTED",

    "userPWD": "REDACTED",

    "webSystem": "WebSites"

  }

]

<publishData>

  <publishProfile

    profileName="ghibli-style-app - Web Deploy"

    publishMethod="MSDeploy"

    publishUrl="ghibli-style-app-csbqbeefd3aueqgb.scm.francecentral-01.azurewebsites.net:443"

    msdeploySite="ghibli-style-app"

    userName="REDACTED"

    userPWD="REDACTED"

    destinationAppUrl="https://ghibli-style-app-csbqbeefd3aueqgb.francecentral-01.azurewebsites.net"

    webSystem="WebSites" />

</publishData>

az webapp deployment list-publishing-profiles --name ghibli-style-app --resource-group ghibli-style-app_group  --query "[?publishMethod=='MSDeploy'].publishXml" --output tsv

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : azure-deploy.yml file

.github/workflows/azure-deploy.yml file:

name: Deploy to Azure App Service

on:

  push:

    branches: [main]

jobs:

  build-and-deploy:

    runs-on: ubuntu-latest

    steps:

    - name: 📥 Checkout code!

      uses: actions/checkout@v3>

    - name: 🐍 Set up Python

      uses: actions/setup-python@v4>

      with:

        python-version: '3.10'

    - name: 📦 Install dependencies

      run: pip install -r requirements.txt

    - name: ✅ Ensure startup.sh is executable

      run: chmod +x startup.sh

    - name: 📁 Create deployment package

      run: zip -r app.zip . -x "*.git*" "*.github*" "app.zip"

    - name: 🔑 Azure Login

      uses: azure/login@v1>

      with:

        creds: ${{ secrets.AZURE_CREDENTIALS }}

    - name: 🚀 Deploy to Azure Web App (Linux)

      run: |

        az webapp deploy \

          --name ghibli-style-app \

          --resource-group ghibli-style-app_group \

          --src-path app.zip \

          --type zip

    - name: 🧪 Afficher le contenu HTML retourné

      run: |

        sleep 30

        echo "🔍 Contenu HTML retourné par l'app :"

        curl -s https://ghibli-style-app-csbqbeefd3aueqgb.francecentral-01.azurewebsites.net

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : requirements.txt

altair==5.5.0
attrs==25.3.0
azure-core==1.35.1
azure-identity==1.25.0
blinker==1.9.0
cachetools==6.2.0
certifi==2025.8.3
cffi==2.0.0
charset-normalizer==3.4.3
click==8.3.0
colorama==0.4.6
cryptography==46.0.1
gitdb==4.0.12
GitPython==3.1.45
idna==3.10
Jinja2==3.1.6
jsonschema==4.25.1
jsonschema-specifications==2025.9.1
MarkupSafe==3.0.3
msal==1.34.0
msal-extensions==1.3.1
narwhals==2.6.0
numpy==2.2.6
packaging==25.0
pandas==2.3.2
pillow==11.3.0
protobuf==6.32.1
pyarrow==21.0.0
pycparser==2.23
pydeck==0.9.1
PyJWT==2.10.1
python-dateutil==2.9.0.post0
python-dotenv==1.1.1
pytz==2025.2
referencing==0.36.2
requests==2.32.5
rpds-py==0.27.1
six==1.17.0
smmap==5.0.2
streamlit==1.50.0
tenacity==9.1.2
toml==0.10.2
tornado==6.5.2
typing_extensions==4.15.0
tzdata==2025.2
urllib3==2.5.0
watchdog==6.0.0

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : web application

Azure Web app:

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : testing

• • Post-deployment test URL: https://ghibli-style-app-csbqbeefd3aueqgb.francecentral-01.azurewebsites.net/
  • Manual tests:
  o Upload a 1024x1024 image or let the code resize.
  o Set the mask area correctly.
  o Start the build and verify the rendering.
  • Logs:
  o On Azure Portal → App Service → Log Stream to view logs in real time.
  o On GitHub → Actions for CI/CD logs.
  • Automated tests (optional):
  o Python script that sends a test image and validates the HTTP 200 return and the presence of a resulting file.

Minimal example of automated testing (pytest or simple script):

python

import requests

def test_health(app_url):

    r = requests.get(app_url)

    assert r.status_code == 200

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : url to test the project

Ghibli Style Generator

https://ghibli-style-app-csbqbeefd3aueqgb.francecentral-01.azurewebsites.net/

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : Ghibli style filter applied to the selfie

Tested in a Windows 11 desktop, the application can work on a phone too:

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : Ghibli style filter applied to the selfie

In production, when i arrive at the event, i take a selfie with my phone. I run the application on the browser of my phone. I upload the picture to Azure. The AI model apply the filter and send me back the modified image. I download the image. I put the image on the social network. 

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : modification field

Bonus: i can apply fine tuning to the filter by adding few words (field "décris la modification"), like: "apply the ghibli filter by adding 20 kg to the person to appear a little fat, big", because Big Data... Big Big Big! ;)

Oh now i'm so big ! for the big big big data & AI ! :)

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : in addition of Ghibli style, i added other styles

I updated the code with options to add other styles:

import streamlit as st
import requests
import base64
from PIL import Image
from io import BytesIO

# hop

# === CONFIGURATION AZURE ===
API_KEY = os.getenv("API_KEY", "API_KEY")

API_VERSION = "2025-04-01-preview"
DEPLOYMENT = "deploiement-FLUX.1-Kontext-pro"
BASE_URL = "https://projet-flux1-kontext-pr-resource.services.ai.azure.com"
#

GENERATION_URL = f"{BASE_URL}/openai/deployments/{DEPLOYMENT}/images/generations?api-version={API_VERSION}"
EDIT_URL = f"{BASE_URL}/openai/deployments/{DEPLOYMENT}/images/edits?api-version={API_VERSION}"

HEADERS_JSON = {
"api-key": API_KEY,
"Content-Type": "application/json"
}
HEADERS_FORM = {
"api-key": API_KEY
}

# === STYLES PRÉDÉFINIS ===
STYLES = [
"Ghibli", "Pixar", "Van Gogh", "Cyberpunk", "Studio Ghibli aquarelle",
"Manga noir et blanc", "Renaissance italienne", "Pop Art", "Low Poly", "Synthwave"
]

# === FONCTIONS UTILITAIRES ===
def decode_image(b64_data):
return Image.open(BytesIO(base64.b64decode(b64_data)))

def generate_image(prompt):
body = {
"prompt": prompt,
"n": 1,
"size": "1024x1024",
"output_format": "png"
}
response = requests.post(GENERATION_URL, headers=HEADERS_JSON, json=body)
if response.status_code != 200:
st.error(f"❌ Erreur génération : {response.text}")
return None
return response.json()["data"][0]["b64_json"]

def edit_image(prompt, image_file):
mime_type = "image/jpeg" if image_file.name.lower().endswith((".jpg", ".jpeg")) else "image/png"
files = {
"image": (image_file.name, image_file, mime_type)
}
data = {
"prompt": prompt,
"n": 1,
"size": "1024x1024"
}
response = requests.post(EDIT_URL, headers=HEADERS_FORM, data=data, files=files)
if response.status_code != 200:
st.error(f"❌ Erreur édition : {response.text}")
return None
return response.json()["data"][0]["b64_json"]

def offer_download(image, filename):
buffer = BytesIO()
image.save(buffer, format="PNG")
st.download_button("📥 Télécharger l’image", buffer.getvalue(), file_name=filename, mime="image/png")

# === INTERFACE STREAMLIT ===
st.set_page_config(page_title="Ghibli Style Generator", page_icon="🎨")
st.title("🎨 Ghibli Style Generator")
st.markdown("Transforme ou stylise tes images avec le modèle FLUX.1-Kontext-pro déployé sur Azure AI Foundry.")

tab1, tab2 = st.tabs(["🚀 Génération sans image", "✏️ Édition d’image existante"])

with tab1:
with st.form("generation_form"):
style = st.selectbox("🎨 Choisis un style", STYLES)
prompt_text = st.text_input("📝 Décris ton image")
submitted = st.form_submit_button("🚀 Générer")
if submitted and prompt_text:
full_prompt = f"{prompt_text}, dans le style {style}"
b64_img = generate_image(full_prompt)
if b64_img:
image = decode_image(b64_img)
st.image(image, caption=f"Image générée ({style})")
offer_download(image, f"image_generee_{style}.png")

with tab2:
with st.form("edit_form"):
uploaded_file = st.file_uploader("📤 Charge une image", type=["png", "jpg", "jpeg"])
style_edit = st.selectbox("🎨 Choisis un style", STYLES, key="edit_style")
edit_prompt_text = st.text_input("📝 Décris la modification")
edit_submitted = st.form_submit_button("✏️ Modifier")
if edit_submitted and uploaded_file and edit_prompt_text:
full_edit_prompt = f"{edit_prompt_text}, dans le style {style_edit}"
b64_edited = edit_image(full_edit_prompt, uploaded_file)
if b64_edited:
image = decode_image(b64_edited)
st.image(image, caption=f"Image éditée ({style_edit})")
offer_download(image, f"image_editee_{style_edit}.png")

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : new styles appear

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : testing cyberpunk style

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : testing Van Gogh style

Awesome! It's as if Van Gogh painted me as a portrait! 

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model: second version of the python code with streamlit : testing pixar style

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model : Security Tips and Best Practices

• Never store the API key in clear text in the repository. Use environment variables or GitHub secrets.
• Limit access to the App Service via authentication if necessary (App Service Authentication, Azure AD).
• Monitor API usage (costs and quotas).
• Add server-side validation for uploaded files (size, type).
• Log errors without exposing keys or sensitive data.

Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model : try it!

Now it's your turn! Try the application by yourself:

-Grab your phone

-Take a selfie

-Open the browser and clic here:  https://ghibli-style-app-csbqbeefd3aueqgb.francecentral-01.azurewebsites.net/

-Wait a little so that streamlit awake.

-Clic on "edition d'une image existante"

-Upload your selfie by pressing the "browse file"

-Find your selfie in the gallery of your phone and clic "open".

-choose a filter (Ghibli...)

-add an additional prompt, exemple: "make the person on the picture fat"

-Clic on "modifier"

-You'll receive your modified selfie with the filter applied.

-Send me your selfie, for exemple by email, and i'll publish it there to thank you...

À vous de jouer ! Essayez l'application par vous-même :

- Prenez votre téléphone

- Prenez un selfie

- Ouvrez votre navigateur et cliquez ici : https://ghibli-style-app-csbqbeefd3aueqgb.francecentral-01.azurewebsites.net/

- Patientez un instant, le temps que Streamlit s'active.

- Cliquez sur « Édition d'une image existante »

- Téléchargez votre selfie en cliquant sur « Parcourir les fichiers ».

- Trouvez votre selfie dans la galerie de votre téléphone et cliquez sur « Ouvrir ».

- Choisissez un filtre (Ghibli…)

- Ajoutez une invite supplémentaire, par exemple : « Grossir la personne sur la photo ».

- Cliquez sur « Modifier ».

- Vous recevrez votre selfie modifié avec le filtre appliqué.

- Envoyez-moi votre selfie, par exemple par email, et je le publierai pour vous remercier.

Yes! :)))))) Big big big... Big data! :)  Thank you for the test :)

Lovely blondie :)  Thank you for the test :)

So sunny in your garden :)  Thank you for the test :)

kawai tiny kawai :)  Thank you for the test :)

Nice smile on the beach, thank you for the test :)

Lol! You look so big! thank you for the test :)

Artificial intelligence added you a moustache! Interesting! Thank you for the test :)

Cute little dog! Thank you for the test :)

Thank you very much to all of you for the user test! Merci à tous pour ce test d'utilisation !

A question? Ask it here

Need help with Azure AI Foundry Web App Python Github Actions Streamlit Ghibli Style Generator FLUX1 Kontext pro model?

Fill this form

[No form id or name provided!]

Azure AI Vision SDK for image analysis explained with Github Copilot

User Rating: 5 / 5

Details

Created: Sunday, 07 September 2025 23:57

Written by Azure.AI.Vision.ImageAnalysis@consultingit.fr

Azure AI Vision SDK for image analysis

When i'm visiting a place people send me messages to ask me if I am the one describing what I see. I answer no, it's computer generated. People don't believe me. I'm so tired of explaining every time that there is no magic, and there's no Harry Potter with me, so that I decided to create this article to explain. Anyone can do the same thing as long as they know a little bit about software development. You can learn by yourself here on Microsoft Learn, and GitHub Copilot even explains if we don't understand something. Lets'go!

This works with Microsoft Cloud Azure. In your subscription, you’ll need to provision an Azure AI Vision resource.

You can also use Azure AI Vision services in an Azure AI Services multi-service resource, either directly or in an Azure AI Foundry project.

Check this guide to know what is Github : Git & Github for beginners and Utiliser Git et GitHub

Azure AI Vision SDK for image analysis explained with Github Copilot : git clone

git clone https://github.com/MicrosoftLearning/mslearn-ai-vision

Or use Visual Studio Code:

"Clone Git Repository"

Select a repository, "ai-vision"...

Cloning into 'mslearn-ai-vision'...

remote: Enumerating objects: 1787, done.

remote: Counting objects: 100% (653/653), done.

remote: Compressing objects: 100% (294/294), done.

remote: Total 1787 (delta 497), reused 424 (delta 354), pack-reused 1134 (from 1)

Receiving objects: 100% (1787/1787), 37.22 MiB | 39.25 MiB/s, done.

Resolving deltas: 100% (856/856), done.

Azure AI Vision SDK for image analysis explained with Github Copilot : create a venv

python -m venv labenv 

Azure AI Vision SDK for image analysis explained with Github Copilot : requirements

pip install -r requirements.txt azure-ai-vision-imageanalysis==1.0.0

Collecting azure-ai-vision-imageanalysis==1.0.0

  Downloading azure_ai_vision_imageanalysis-1.0.0-py3-none-any.whl.metadata (22 kB)

Collecting dotenv (from -r requirements.txt (line 1))

  Downloading dotenv-0.9.9-py2.py3-none-any.whl.metadata (279 bytes)

Collecting matplotlib (from -r requirements.txt (line 2))

  Downloading matplotlib-3.10.6-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (11 kB)

Collecting pillow (from -r requirements.txt (line 3))

  Downloading pillow-11.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl.metadata (9.0 kB)

Collecting isodate>=0.6.1 (from azure-ai-vision-imageanalysis==1.0.0)

  Downloading isodate-0.7.2-py3-none-any.whl.metadata (11 kB)

Collecting azure-core>=1.30.0 (from azure-ai-vision-imageanalysis==1.0.0)

  Downloading azure_core-1.35.0-py3-none-any.whl.metadata (44 kB)

Collecting typing-extensions>=4.6.0 (from azure-ai-vision-imageanalysis==1.0.0)

  Downloading typing_extensions-4.15.0-py3-none-any.whl.metadata (3.3 kB)

Collecting python-dotenv (from dotenv->-r requirements.txt (line 1))

  Downloading python_dotenv-1.1.1-py3-none-any.whl.metadata (24 kB)

Collecting contourpy>=1.0.1 (from matplotlib->-r requirements.txt (line 2))

  Downloading contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl.metadata (5.5 kB)

Collecting cycler>=0.10 (from matplotlib->-r requirements.txt (line 2))

  Downloading cycler-0.12.1-py3-none-any.whl.metadata (3.8 kB)

Collecting fonttools>=4.22.0 (from matplotlib->-r requirements.txt (line 2))

  Downloading fonttools-4.59.2-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl.metadata (109 kB)

Collecting kiwisolver>=1.3.1 (from matplotlib->-r requirements.txt (line 2))

  Downloading kiwisolver-1.4.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (6.3 kB)

Collecting numpy>=1.23 (from matplotlib->-r requirements.txt (line 2))

  Downloading numpy-2.3.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl.metadata (62 kB)

Collecting packaging>=20.0 (from matplotlib->-r requirements.txt (line 2))

  Downloading packaging-25.0-py3-none-any.whl.metadata (3.3 kB)

Collecting pyparsing>=2.3.1 (from matplotlib->-r requirements.txt (line 2))

  Downloading pyparsing-3.2.3-py3-none-any.whl.metadata (5.0 kB)

Collecting python-dateutil>=2.7 (from matplotlib->-r requirements.txt (line 2))

  Downloading python_dateutil-2.9.0.post0-py2.py3-none-any.whl.metadata (8.4 kB)

Collecting requests>=2.21.0 (from azure-core>=1.30.0->azure-ai-vision-imageanalysis==1.0.0)

  Downloading requests-2.32.5-py3-none-any.whl.metadata (4.9 kB)

Collecting six>=1.11.0 (from azure-core>=1.30.0->azure-ai-vision-imageanalysis==1.0.0)

  Downloading six-1.17.0-py2.py3-none-any.whl.metadata (1.7 kB)

Collecting charset_normalizer<4,>=2 (from requests>=2.21.0->azure-core>=1.30.0->azure-ai-vision-imageanalysis==1.0.0)

  Downloading charset_normalizer-3.4.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl.metadata (36 kB)

Collecting idna<4,>=2.5 (from requests>=2.21.0->azure-core>=1.30.0->azure-ai-vision-imageanalysis==1.0.0)

  Downloading idna-3.10-py3-none-any.whl.metadata (10 kB)

Collecting urllib3<3,>=1.21.1 (from requests>=2.21.0->azure-core>=1.30.0->azure-ai-vision-imageanalysis==1.0.0)

  Downloading urllib3-2.5.0-py3-none-any.whl.metadata (6.5 kB)

Collecting certifi>=2017.4.17 (from requests>=2.21.0->azure-core>=1.30.0->azure-ai-vision-imageanalysis==1.0.0)

  Downloading certifi-2025.8.3-py3-none-any.whl.metadata (2.4 kB)

Downloading azure_ai_vision_imageanalysis-1.0.0-py3-none-any.whl (64 kB)

Downloading dotenv-0.9.9-py2.py3-none-any.whl (1.9 kB)

Downloading matplotlib-3.10.6-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (8.7 MB)

   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 8.7/8.7 MB 67.4 MB/s eta 0:00:00

Downloading pillow-11.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (6.6 MB)

   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 6.6/6.6 MB 82.6 MB/s eta 0:00:00

Downloading azure_core-1.35.0-py3-none-any.whl (210 kB)

Downloading contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (362 kB)

Downloading cycler-0.12.1-py3-none-any.whl (8.3 kB)

Downloading fonttools-4.59.2-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl (4.9 MB)

   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 4.9/4.9 MB 70.0 MB/s eta 0:00:00

Downloading isodate-0.7.2-py3-none-any.whl (22 kB)

Downloading kiwisolver-1.4.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (1.5 MB)

   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 1.5/1.5 MB 34.8 MB/s eta 0:00:00

Downloading numpy-2.3.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (16.6 MB)

   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 16.6/16.6 MB 92.7 MB/s eta 0:00:00

Downloading packaging-25.0-py3-none-any.whl (66 kB)

Downloading pyparsing-3.2.3-py3-none-any.whl (111 kB)

Downloading python_dateutil-2.9.0.post0-py2.py3-none-any.whl (229 kB)

Downloading typing_extensions-4.15.0-py3-none-any.whl (44 kB)

Downloading python_dotenv-1.1.1-py3-none-any.whl (20 kB)

Downloading requests-2.32.5-py3-none-any.whl (64 kB)

Downloading six-1.17.0-py2.py3-none-any.whl (11 kB)

Downloading certifi-2025.8.3-py3-none-any.whl (161 kB)

Downloading charset_normalizer-3.4.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl (151 kB)

Downloading idna-3.10-py3-none-any.whl (70 kB)

Downloading urllib3-2.5.0-py3-none-any.whl (129 kB)

Installing collected packages: urllib3, typing-extensions, six, python-dotenv, pyparsing, pillow, packaging, numpy, kiwisolver, isodate, idna, fonttools, cycler, charset_normalizer, certifi, requests, python-dateutil, dotenv, contourpy, matplotlib, azure-core, azure-ai-vision-imageanalysis

Successfully installed azure-ai-vision-imageanalysis-1.0.0 azure-core-1.35.0 certifi-2025.8.3 charset_normalizer-3.4.3 contourpy-1.3.3 cycler-0.12.1 dotenv-0.9.9 fonttools-4.59.2 idna-3.10 isodate-0.7.2 kiwisolver-1.4.9 matplotlib-3.10.6 numpy-2.3.2 packaging-25.0 pillow-11.3.0 pyparsing-3.2.3 python-dateutil-2.9.0.post0 python-dotenv-1.1.1 requests-2.32.5 six-1.17.0 typing-extensions-4.15.0 urllib3-2.5.0

[notice] A new release of pip is available: 24.3.1 -> 25.2

[notice] To update, run: pip install --upgrade pip

Azure AI Vision SDK for image analysis explained with Github Copilot : modify the env

code .env

(to modify Keys and Endpoint )

Azure AI Vision SDK for image analysis explained with Github Copilot : open code in visual studio code

To know what is Python langage, checjk this: Cours python en ligne gratuit français. Base du langage

code image-analysis.py

from dotenv import load_dotenv

import os

from PIL import Image, ImageDraw

import sys

from matplotlib import pyplot as plt

from azure.core.exceptions import HttpResponseError

import requests

# import namespaces

from azure.ai.vision.imageanalysis import ImageAnalysisClient

from azure.ai.vision.imageanalysis.models import VisualFeatures

from azure.core.credentials import AzureKeyCredential

def main():

    # Clear the console

    os.system('cls' if os.name=='nt' else 'clear')

    try:

        # Get Configuration Settings

        load_dotenv()

        ai_endpoint = os.getenv('AI_SERVICE_ENDPOINT')

        ai_key = os.getenv('AI_SERVICE_KEY')

        # Get image

        image_file = 'images/street.jpg'

        if len(sys.argv) > 1:

            image_file = sys.argv[1]

        # Authenticate Azure AI Vision client

        cv_client = ImageAnalysisClient(

            endpoint=ai_endpoint,

            credential=AzureKeyCredential(ai_key))

        # Analyze image

        with open(image_file, "rb") as f:

            image_data = f.read()

        print(f'\nAnalyzing {image_file}\n')

        result = cv_client.analyze(

            image_data=image_data,

            visual_features=[

                VisualFeatures.CAPTION,

                VisualFeatures.DENSE_CAPTIONS,

                VisualFeatures.TAGS,

                VisualFeatures.OBJECTS,

                VisualFeatures.PEOPLE],

        )

        # Get image captions

        if result.caption is not None:

            print("\nCaption:")

            print(" Caption: '{}' (confidence: {:.2f}%)".format(result.caption.text, result.caption.confidence * 100))

        if result.dense_captions is not None:

            print("\nDense Captions:")

            for caption in result.dense_captions.list:

                print(" Caption: '{}' (confidence: {:.2f}%)".format(caption.text, caption.confidence * 100))

        # Get image tags

if result.tags is not None:

    print("\nTags:")

    for tag in result.tags.list:

        print(" Tag: '{}' (confidence: {:.2f}%)".format(tag.name, tag.confidence * 100))

        # Get objects in the image

if result.objects is not None:

     print("\nObjects in image:")

     for detected_object in result.objects.list:

         # Print object tag and confidence

         print(" {} (confidence: {:.2f}%)".format(detected_object.tags[0].name, detected_object.tags[0].confidence * 100))

     # Annotate objects in the image

     show_objects(image_file, result.objects.list)

        # Get people in the image

if result.people is not None:

     print("\nPeople in image:")

     for detected_person in result.people.list:

         if detected_person.confidence > 0.2:

             # Print location and confidence of each person detected

             print(" {} (confidence: {:.2f}%)".format(detected_person.bounding_box, detected_person.confidence * 100))

     # Annotate people in the image

     show_people(image_file, result.people.list)

    except Exception as ex:

        print(ex)

def show_objects(image_filename, detected_objects):

    print ("\nAnnotating objects...")

    # Prepare image for drawing

    image = Image.open(image_filename)

    fig = plt.figure(figsize=(image.width/100, image.height/100))

    plt.axis('off')

    draw = ImageDraw.Draw(image)

    color = 'cyan'

    for detected_object in detected_objects:

        # Draw object bounding box

        r = detected_object.bounding_box

        bounding_box = ((r.x, r.y), (r.x + r.width, r.y + r.height)) 

        draw.rectangle(bounding_box, outline=color, width=3)

        plt.annotate(detected_object.tags[0].name,(r.x, r.y), backgroundcolor=color)

    # Save annotated image

    plt.imshow(image)

    plt.tight_layout(pad=0)

    objectfile = 'objects.jpg'

    fig.savefig(objectfile)

    print('  Results saved in', objectfile)

def show_people(image_filename, detected_people):

    print ("\nAnnotating objects...")

    # Prepare image for drawing

    image = Image.open(image_filename)

    fig = plt.figure(figsize=(image.width/100, image.height/100))

    plt.axis('off')

    draw = ImageDraw.Draw(image)

    color = 'cyan'

    for detected_person in detected_people:

        if detected_person.confidence > 0.2:

            # Draw object bounding box

            r = detected_person.bounding_box

            bounding_box = ((r.x, r.y), (r.x + r.width, r.y + r.height))

            draw.rectangle(bounding_box, outline=color, width=3)

    # Save annotated image

    plt.imshow(image)

    plt.tight_layout(pad=0)

    peoplefile = 'people.jpg'

    fig.savefig(peoplefile)

    print('  Results saved in', peoplefile)

if __name__ == "__main__":

    main()

Azure AI Vision SDK for image analysis explained with Github Copilot : choose the model

We can choose the model : Claude Sonnet 3.5 , Gemini 2.0 Flash , GPT-4.1 , GPT-4o, GPT-5 mini (Preview), o3-mini

Azure AI Vision SDK for image analysis explained with Github Copilot : explain import namspaces

Azure AI Vision SDK for image analysis explained with Github Copilot : @workspace explain

Next, Github Copilot answer:

"You have several issues:

Expected indented block: This usually means Python expects an indented code block after a statement like if, for, def, or class. Make sure your code structure is correct.

Import could not be resolved: This means the required packages are not installed in your environment.

Unused imports: You have imported modules or classes that are not used in your code.

How to fix

1. Install missing packages

Open your VS Code terminal and run:

pip install python-dotenv pillow azure-ai-vision azure-core matplotlib requests"

Azure AI Vision SDK for image analysis explained with Github Copilot : explain Get image

Github Copilot: "This code snippet is responsible for determining which image file will be analyzed by the program. By default, it sets image_file to 'images/street.jpg', meaning that if the user does not provide any additional input, the program will use this image. However, the next two lines check if any command-line arguments were provided when the script was run. The sys.argv list contains all command-line arguments passed to the script, with the first element (sys.argv[0]) being the script name itself. If the length of sys.argv is greater than 1, it means the user has supplied at least one argument after the script name. In that case, the code assigns the first argument (sys.argv[1]) to image_file, allowing the user to specify a different image file to analyze. This approach makes the script flexible, supporting both a default image and user-specified images via the command line."

Azure AI Vision SDK for image analysis explained with Github Copilot : explain Analyze image

Github Copilot: "This section of code is responsible for sending the selected image to the Azure AI Vision service for analysis. First, it opens the image file specified by image_file in binary read mode ("rb"), reads its contents into the variable image_data, and then closes the file automatically thanks to the with statement. This ensures the image data is ready to be sent to the analysis service. Next, the code prints a message to the console indicating which image is being analyzed, providing feedback to the user. The core operation follows: the cv_client.analyze method is called, passing in the image data and a list of visual features to extract. These features include captions, dense captions, tags, objects, and people, as specified by the VisualFeatures enumeration. The result of this analysis is stored in the result variable, which can then be used to access the detected features and their details. This approach allows the program to flexibly analyze various aspects of the image in a single API call."

Azure AI Vision SDK for image analysis explained with Github Copilot : generate doc

Github Copilot: "

    Main function to analyze an image using Azure AI Vision services.

    This function performs the following steps:

    1. Clears the console for better readability.

    2. Loads configuration settings (endpoint and key) from environment variables.

    3. Determines the image file to analyze, either from command-line arguments or a default path.

    4. Authenticates the Azure AI Vision client using the provided credentials.

    5. Reads the image file and sends it to the Azure AI Vision service for analysis, requesting captions, dense captions, tags, objects, and people detection.

    6. Prints the analysis results, including captions, dense captions, and tags with their confidence scores.

    7. Handles and prints any exceptions that occur during execution.

    ""

Azure AI Vision SDK for image analysis explained with Github Copilot : run the code with an image

python image-analysis.py image.jpg

Azure AI Vision SDK for image analysis explained with Github Copilot : basic results

Caption:

 Caption: 'a man walking a dog on a leash on a street' (confidence: 82.07%)

Dense Captions:

 Caption: 'a man walking a dog on a leash on a street' (confidence: 82.06%)

 Caption: 'a man walking on a street' (confidence: 69.02%)

 Caption: 'a yellow car on the street' (confidence: 78.22%)

 Caption: 'a black dog walking on the street' (confidence: 75.31%)

 Caption: 'a blurry image of a blue car' (confidence: 82.01%)

 Caption: 'a yellow taxi cab on the street' (confidence: 72.44%)

Caption:

 Caption: 'a man in a suit' (confidence: 78.55%)

Dense Captions:

 Caption: 'a man in a suit' (confidence: 78.55%)

 Caption: 'a man in a suit giving a thumbs up' (confidence: 80.96%)

Tags:

 Tag: 'outdoor' (confidence: 99.87%)

 Tag: 'land vehicle' (confidence: 99.02%)

 Tag: 'vehicle' (confidence: 98.89%)

 Tag: 'building' (confidence: 98.55%)

 Tag: 'road' (confidence: 95.98%)

 Tag: 'wheel' (confidence: 95.14%)

 Tag: 'street' (confidence: 94.71%)

 Tag: 'person' (confidence: 93.01%)

 Tag: 'clothing' (confidence: 91.19%)

 Tag: 'taxi' (confidence: 90.95%)

 Tag: 'car' (confidence: 84.01%)

 Tag: 'dog' (confidence: 82.68%)

 Tag: 'yellow' (confidence: 77.08%)

 Tag: 'walking' (confidence: 74.11%)

 Tag: 'city' (confidence: 64.80%)

 Tag: 'woman' (confidence: 57.53%)

Tags:

 Tag: 'outdoor' (confidence: 99.93%)

 Tag: 'cloud' (confidence: 99.79%)

 Tag: 'grass' (confidence: 99.76%)

 Tag: 'tree' (confidence: 99.09%)

 Tag: 'sky' (confidence: 98.95%)

 Tag: 'building' (confidence: 96.15%)

 Tag: 'dome' (confidence: 91.38%)

 Tag: 'presidential palace' (confidence: 91.03%)

 Tag: 'landmark' (confidence: 89.98%)

 Tag: 'palace' (confidence: 89.63%)

 Tag: 'plant' (confidence: 88.77%)

 Tag: 'courthouse' (confidence: 84.78%)

 Tag: 'field' (confidence: 82.64%)

 Tag: 'city' (confidence: 76.11%)

 Tag: 'large' (confidence: 68.73%)

 Tag: 'park' (confidence: 54.24%)

Caption:

 Caption: 'a man walking a dog on a leash on a street' (confidence: 82.07%)

Dense Captions:

 Caption: 'a man walking a dog on a leash on a street' (confidence: 82.07%)

 Caption: 'a man walking on a street' (confidence: 69.02%)

 Caption: 'a yellow car on the street' (confidence: 78.17%)

 Caption: 'a black dog walking on the street' (confidence: 75.31%)

 Caption: 'a blurry image of a blue car' (confidence: 82.01%)

 Caption: 'a yellow taxi cab on the street' (confidence: 72.44%)

Tags:

 Tag: 'outdoor' (confidence: 99.87%)

 Tag: 'land vehicle' (confidence: 99.02%)

 Tag: 'vehicle' (confidence: 98.89%)

 Tag: 'building' (confidence: 98.55%)

 Tag: 'road' (confidence: 95.98%)

 Tag: 'wheel' (confidence: 95.14%)

 Tag: 'street' (confidence: 94.71%)

 Tag: 'person' (confidence: 93.01%)

 Tag: 'clothing' (confidence: 91.19%)

 Tag: 'taxi' (confidence: 90.95%)

 Tag: 'car' (confidence: 84.01%)

 Tag: 'dog' (confidence: 82.68%)

 Tag: 'yellow' (confidence: 77.08%)

 Tag: 'walking' (confidence: 74.11%)

 Tag: 'city' (confidence: 64.80%)

 Tag: 'woman' (confidence: 57.53%)

Objects in image:

 car (confidence: 72.40%)

 taxi (confidence: 77.00%)

 person (confidence: 78.10%)

 dog (confidence: 54.40%)

Dense Captions:

 Caption: 'a man walking a dog on a leash on a street' (confidence: 82.07%)

 Caption: 'a man walking on a street' (confidence: 69.02%)

 Caption: 'a yellow car on the street' (confidence: 78.22%)

 Caption: 'a black dog walking on the street' (confidence: 75.31%)

 Caption: 'a blurry image of a blue car' (confidence: 82.01%)

 Caption: 'a yellow taxi cab on the street' (confidence: 72.44%)

Tags:

 Tag: 'outdoor' (confidence: 99.87%)

 Tag: 'land vehicle' (confidence: 99.02%)

 Tag: 'vehicle' (confidence: 98.89%)

 Tag: 'building' (confidence: 98.55%)

 Tag: 'road' (confidence: 95.98%)

 Tag: 'wheel' (confidence: 95.14%)

 Tag: 'street' (confidence: 94.71%)

 Tag: 'person' (confidence: 93.01%)

 Tag: 'clothing' (confidence: 91.19%)

 Tag: 'taxi' (confidence: 90.95%)

 Tag: 'car' (confidence: 84.01%)

 Tag: 'dog' (confidence: 82.68%)

 Tag: 'yellow' (confidence: 77.08%)

 Tag: 'walking' (confidence: 74.11%)

 Tag: 'city' (confidence: 64.80%)

 Tag: 'woman' (confidence: 57.53%)

Objects in image:

 car (confidence: 72.40%)

 taxi (confidence: 77.00%)

 person (confidence: 78.10%)

 dog (confidence: 54.40%)

Annotating objects...

  Results saved in objects.jpg

People in image:

 {'x': 241, 'y': 109, 'w': 155, 'h': 399} (confidence: 94.99%)

 {'x': 396, 'y': 264, 'w': 23, 'h': 58} (confidence: 24.93%)

 {'x': 699, 'y': 262, 'w': 20, 'h': 33} (confidence: 22.45%)

 Annotating objects...

  Results saved in people.jpg

Azure AI Vision SDK for image analysis explained with Github Copilot : describe the image with NLP natural language processing

Now with the tags outdoor,land vehicle,vehicle,building,road,wheel,street,person,clothing,taxi,car,dog,yellow,walking,city, we can ask Azure Open AI to describe the image in natural langage processing, check AI Azure Open AI Intégration Chatbot avec RAG CosmosDB depuis fork GIT POC MVP 

We can use for exemple the model "Phi-4-multimodal-instruct" or "GPT-4o mini" etc.

 " In the image, a person is seen walking a black dog along a bustling street in an urban city environment. The individual is dressed in a smart suit, which adds a touch of professionalism to the scene. He appears to be enjoying a leisurely stroll, perhaps on his way to work or a meeting, as he holds a smartphone in one hand while guiding the dog with the other.

The road is lined with several yellow taxis, iconic to many metropolitan areas, indicating a vibrant atmosphere where transportation is readily available. These land vehicles are parked along the curb, showcasing their distinct color and design, which contrasts with the more muted tones of the surrounding buildings. The architecture in the background features classic city elements, with tall structures that hint at the historical significance of the area.

The wheel of the taxis is visible, emphasizing the movement and activity typical of city life. The scene captures a moment of interaction between the man and his dog, highlighting the companionship that exists in urban settings. The presence of the dog adds a layer of warmth to the otherwise busy environment, suggesting a balance between work and leisure.

Overall, this image encapsulates the essence of outdoor life in a city, where people navigate their daily routines amidst the hustle and bustle. The combination of the person, dog, vehicles, and buildings creates a dynamic snapshot of urban living, reflecting both the challenges and joys of city life. "

A question? Ask it here

Need help with Azure AI Vision SDK for image analysis?

Fill this form

[No form id or name provided!]

LGHM candidature pour un stage d'observation

User Rating: 5 / 5

Details

Created: Monday, 12 May 2025 21:00

Written by Association LGHM

[No form id or name provided!]

Pour candidater: remplissez ce formulaire ou envoyez un email avec CV à This email address is being protected from spambots. You need JavaScript enabled to view it. 

DESCRIPTIF DE POSTE