Page MenuHomePhabricator

Public-facing API for querying image suggestion recommendations and submitting user feedback
Open, LowPublic

Description

Request Status: New Request
Request Type: project support request
Related OKRs: Product Platform O: Our platform and processes are ready and able to invite all of the world's population to join us. KR 1: Machines are able to recognize Wikimedia content and suggest relations to other Wikimedia content in at least 2 wikis, enabling experimentation with at least two new strategic features.

Request Title: Public-facing API for image suggestions data

  • Request Description: By the end of June, we will have a pipeline for image suggestions data as well as an internal-only API to access that data (see T304891). We have some users who are interested in building tools using this API. For example, WMPT expressed interest in building a tool that specifically targets campaigns of users with notifications in a particular category. However, without access to the API, users cannot build gadgets or tools or other services using this data. Additionally, a public-facing API will be helpful with QA and testing of MediaWiki code that integrates with the image suggestions API.
  • Indicate Priority Level:
  • Main Requestors: Structured Data team (@CBogen and @SWakiyama)
  • Ideal Delivery Date: September 1, 2022
  • Stakeholders: Structured Data team, Growth team, interested community members

Request Documentation

Document TypeRequired?Document/Link
Related PHAB TicketsYesPhab ticket for the currently planned internal-facing API: T304891
Product One PagerYes<add link here>
Product Requirements Document (PRD)YesPRD for the image suggestions notifications
Product RoadmapNo<add link here>
Product Planning/Business CaseNo<add link here>
Product BriefNo<add link here>
Other LinksNo<add links here>

Related Objects

Event Timeline

There are a very large number of changes, so older changes are hidden. Show Older Changes

Hi @DAbad @lbowmaker - Do you have an estimate when this API would be public facing? This would be really helpful for the Android team. Thanks!

VirginiaPoundstone raised the priority of this task from Medium to High.Oct 7 2022, 4:01 PM
VirginiaPoundstone moved this task from Incoming to Needs Grooming on the API Platform board.
VirginiaPoundstone lowered the priority of this task from High to Medium.Oct 7 2022, 7:22 PM

Hey there, commenting here the priority of this API being public facing for the Android team and other teams that may need it. I believe the Structured Data team is another team that may need it public facing. I also know iOS has on their roadmap to bring in suggested edits for their users, so they would also use the API. We were hoping to start working on image recommendations starting this month. Can we get an estimation of when it could become public facing so we can know if we should explore if proxying is possible in the absence of an API

Looping in @hnowlan on requirements gathering from @JTannerWMF.

In order to give an estimation on delivery of a public facing API, I need to learn more about your requirements:

  • We assume that login is not required when using the public facing image suggestion API, please confirm.
  • What are the app's rate limit requirements? Our default for non-logged in usage is 500 requests per hour. If you need more, please give specifications. If needed, will use tokens to increase the request limit.

You mentioned that you are starting work this month, do you have a release date for the feature?

From our preliminary review it seems like it would be a well-contained project that we would love to work on. We hope we can meet your timeline requirements.

Both assumptions and requirements are correct! We are flexible on release, but ideally by January, how does that work?

Regarding implementation approach, I notice that @kostajh suggested above implementing this within the GrowthExperiments extension:

OK, then instead of a fully-developed application and Kubernetes service to act as the front-end for the Data Gateway, another thought I had was to consider creating a REST endpoint with the GrowthExperiments extension, and to proxy requests to the Data Gateway via that endpoint.

An alternative would be a small standalone service similar to what we're doing for some of the AQS 2.0 endpoints. It would essentially do the same thing: expose a REST endpoint that proxies requests to the Data Gateway. Rather than being a generic, full-featured front end to the Data Gateway, it would be a small, tightly scoped service that wrapped this one endpoint with the desired validation and error handling.

Not being very familiar with the GrowthExperiments extension, I don't have a strong opinion. I like the separation of concerns that a separate service would provide. However, it would be a new deployment, with all the attending considerations (security review, repository, pipeline, etc.). I see link recommendations mentioned, but I'm not familiar with how it was implemented. Are there patterns/learnings from link recommendations that would push us one direction or another?

Also to confirm: is the the GrowthExperiments extension available on all wikis where image suggestions are desired?

A few more clarifications from the API gateway side of things:

  • Do you have an idea of what the traffic for this endpoint would be? We have no limits, but a vague idea would be nice from a scaling perspective. Doesn't have to be a hard number, proportions or estimations are fine.
  • Do you still only require access for GET requests? Do these requests require authentication or anything similar?
  • (later term if needs be) It'd be really handy to have an internal hostname for the service and a URL that we can test against to be sure that request proxying is working as expected.

Just to update Virginia's comment about rate limits above, that is 500 requests per hour per unique IP. We can set custom anonymous limits if needs be, and clients can deploy JWTs to get access to higher limits also if suitable (and we can define custom classes for those clients if needs be).

If we had an actual API rather than just a proxy/wrapper then it would allow us to do a few extra things:

  • accept feedback on whether an image is a good/bad suggestion directly and synchronously (obvs this would require us to accept POST requests)
  • ... and then as a consequence filter out suggestions that have already had feedback in realtime, rather than solely during generation of the dataset

If we had an actual API rather than just a proxy/wrapper then it would allow us to do a few extra things:

  • accept feedback on whether an image is a good/bad suggestion directly and synchronously (obvs this would require us to accept POST requests)
  • ... and then as a consequence filter out suggestions that have already had feedback in realtime, rather than solely during generation of the dataset

We could conceivably also expose a POST endpoint in a REST route for GrowthExperiments. Then we would get some benefits like verifying user is logged-in.

And to an earlier question: yes, GrowthExperiments is on all Wikipedias.

Ok so AIUI the following are the endpoints that we need from public image-suggestions API. See here for what the Cassandra tables hold

GET /suggestions/<wiki>/<page_id>

GET /title_cache/<wiki>/<page_title>

GET /instanceof_cache/<wiki>/<page_id>

POST /suggestions/feedback 
{ 
    "wiki": wiki, 
    "page_id": page_id of the article-with-suggestion we're providing feedback on,
    "filename": filename of suggestion,
    "origin_wiki": the wiki the suggestion is from - atm this will always be "commons", so maybe this param is unnecessary?,
    "user_id": the user submitting the feedback,
    "is_accepted": true/false,
    "is_rejected": true/false ... probably we only one or other of is_accepted and is_rejected and the API itself can handle the logic,
    "rejection_reason": user-submitted comment for a rejection
}

@JTannerWMF does this meet your needs? @VirginiaPoundstone @BPirkle does this seem reasonable ?

POST /suggestions/feedback 
{ 
    "wiki": wiki, 
    "page_id": page_id of the article-with-suggestion we're providing feedback on,
    "filename": filename of suggestion,
    "origin_wiki": the wiki the suggestion is from - atm this will always be "commons", so maybe this param is unnecessary?,
    "user_id": the user submitting the feedback,
    "is_accepted": true/false,
    "is_rejected": true/false ... probably we only one or other of is_accepted and is_rejected and the API itself can handle the logic,
    "rejection_reason": user-submitted comment for a rejection
}

Currently we require JWTs for all POST requests to the gateway - I assume this isn't an option for Android clients so we can talk about relaxing this requirement.

The GET endpoints look straightfoward. We could implement them in a variety of ways, any of which would probably be fine.

The POST endpoint needs a bit more care, though. To clarify, does/should the POST endpoint require authentication? If not, are we comfortable with the prospect of people POSTing bad data as a form of abuse?

And to turn Hugh's assumption above into an explicit question, is the Android client capable of providing JWTs for authentication (presumably OAuth 2 tokens acquired from metawiki)?

We can still implement the POST endpoint regardless of the answers to those questions. But the answers may direct the implementation one way or another.

Actually ... now that I think about it, @VirginiaPoundstone and @BPirkle is there scope to move some of the business logic into the API, so that each client doesn't have to implement it separately? IMO it'd make a lot of sense to do that

If there is scope, then Growth and us and Android need to have a little chat to figure out what we need ...

Actually ... now that I think about it, @VirginiaPoundstone and @BPirkle is there scope to move some of the business logic into the API, so that each client doesn't have to implement it separately? IMO it'd make a lot of sense to do that

If there is scope, then Growth and us and Android need to have a little chat to figure out what we need ...

Just chiming in here to say: It was my assumption from the beginning that this would be the case, but now that it's being asked, I'm thinking it was an unsafe assumption(!) IMO it would be a big mistake not to; Replicating that business logic over multiple systems would be a Bad Idea™.

Some open questions (sorry if I've missed the answers somewhere):

  1. does/should the POST endpoint require authentication? If not, are we comfortable with the prospect of people POSTing bad data as a form of abuse?
  2. is the Android client capable of providing JWTs for authentication (presumably OAuth 2 tokens acquired from metawiki)? If not, what kind of authentication can it handle? Are there other potential clients whose authentication capabilities we should consider?
  3. regarding moving "business logic" into the API: what kind of logic are we talking about? It there documentation/discussion recorded anywhere? I'm hesitant to say if could be in scope without knowing more.
  4. can EventGate accept events from a non-MediaWiki service that lives within our network?

Regarding #4, I know virtually nothing about EventGate, but this came up in T320739: Provide API module in GrowthExperiments to allow querying image suggestion API for titles. It wasn't clear to me in that task whether the question was whether EventGate could/should accept external (public, from the open internet) events, or whether it could/should accept events from things other than MediaWiki that live on our production servers.

Grabbing just #4, since I can answer that one.

  1. can EventGate accept events from a non-MediaWiki service that lives within our network?

Regarding #4, I know virtually nothing about EventGate, but this came up in T320739: Provide API module in GrowthExperiments to allow querying image suggestion API for titles. It wasn't clear to me in that task whether the question was whether EventGate could/should accept external (public, from the open internet) events, or whether it could/should accept events from things other than MediaWiki that live on our production servers.

So, the clarifying question would be, which EventGate? EventGate is just a software, of which we have 4 installations (and the main reason is separation of concerns[1]) They are documented here: https://wikitech.wikimedia.org/wiki/Event_Platform/EventGate#EventGate_clusters, but the TL;DR is:

  • eventgate-main => internal only, events generated by MediaWiki and services are posted here
  • eventgate-analytics => analytics only, internal only, kinda eqiad only (at least the backend kafka cluster). Multiple things post here.
  • eventgate-analytics-external => Same as the internally named one, but publicly available, again multiple things post here.
  • eventgate-logging-external => public, logging specific, again multiple things post here.

So, overall the answer to "can EventGate accept events from a non-MediaWiki service that lives within our network?" is always yes, but depending on what the event is going to be about and who is expected to react to it, you want a different eventgate installation.

[1] https://en.wikipedia.org/wiki/Separation_of_concerns

  1. regarding moving "business logic" into the API: what kind of logic are we talking about? It there documentation/discussion recorded anywhere? I'm hesitant to say if could be in scope without knowing more.

No documentation/discussion recorded, no. What I'm thinking about is stuff like:

  • a /suggestions/<wiki>/ endpoint without a page_id, where the API would query elasticsearch (or the action api) under the hood ... this would allow clients to not have to know about the hasrecommendation:image stuff in elastic. Growth probably wouldn't use this endpoint initially because their code has the current infra baked into it pretty deeply, but it'd simplify things for SD and Android
  • currently recommendations-with-feedback are only filtered out when the dataset is generated - they could also be filtered out by the API in case there is new feedback since the last dataset was generated

... and a few other things besides involving the title_cache and instanceof_cache tables. Obvs you can't commit to anything without knowing what it is @BPirkle - just wanted to make sure you guys have the resources to do something other than a bare wrapping layer for the Cassandra data gateway. If you have then that'd be great, and then obvs the next step would be to work out exactly what that might be, and prioritise etc etc

To answer a couple of questions:

GET /suggestions/<wiki>/<page_id>
GET /title_cache/<wiki>/<page_title>
GET /instanceof_cache/<wiki>/<page_id>
POST /suggestions/feedback

@Cparle Thanks, those endpoints sound good, and the extra endpoint of /suggestions/<wiki>/ without page_id would be quite beneficial, and would simplify things for us considerably.

  1. is the Android client capable of providing JWTs for authentication (presumably OAuth 2 tokens acquired from metawiki)? If not, what kind of authentication can it handle? Are there other potential clients whose authentication capabilities we should consider?

@BPirkle Unfortunately not at the moment. We're simply using centralauth cookies.

To answer a couple of questions:

GET /suggestions/<wiki>/<page_id>
GET /title_cache/<wiki>/<page_title>
GET /instanceof_cache/<wiki>/<page_id>
POST /suggestions/feedback

@Cparle Thanks, those endpoints sound good, and the extra endpoint of /suggestions/<wiki>/ without page_id would be quite beneficial, and would simplify things for us considerably.

Out of curiosity, does the on-wiki search endpoint work for your use case? E.g. https://en.wikipedia.org/w/api.php?action=query&format=json&list=search&formatversion=2&srsearch=hasrecommendation%3Aimage which yields results like:

{
  "batchcomplete": true,
  "continue": {
    "sroffset": 10,
    "continue": "-||"
  },
  "query": {
    "searchinfo": {
      "totalhits": 96381
    },
    "search": [
      {
        "ns": 0,
        "title": "Deaths in 2022",
        "pageid": 69407798,
        "size": 150555,
        "wordcount": 10900,
        "snippet": "The following notable deaths occurred in 2022. Names are reported under the date of death, in alphabetical order. A typical entry reports information in",
        "timestamp": "2022-10-25T08:49:54Z"
      },
      {
        "ns": 0,
        "title": "Single-player video game",
        "pageid": 497340,
        "size": 11710,
        "wordcount": 1318,
        "snippet": "A single-player video game is a video game where input from only one player is expected throughout the course of the gaming session. A single-player game",
        "timestamp": "2022-10-14T22:19:02Z"
      },

Using ElasticSearch as the "place where I can get a list of articles with image recommendations" has some advantages:

  • easy to randomize the results using the sort parameter
  • pagination of results
  • combine with other filters, like hastemplate or -hastemplate to include/exclude articles based on templates present in the article content
  • keyword search (e.g. "football hasrecommendation:image")
  • flexible AND/OR usage for articletopic keyword

Re-implementing that feature set in the image suggestion API seems like a lot of extra work, IMHO.

For Growth features, we make use of community-defined lists of templates (see https://es.wikipedia.org/wiki/MediaWiki:NewcomerTasks.json and https://es.wikipedia.org/wiki/MediaWiki:GrowthExperimentsConfig.json) to, for example, prevent users from seeing image recommendations for articles that have infoboxes (see GEInfoboxTemplates in /MediaWiki:GrowthExperimentsConfig.json). Since each community would have different templates to list there, baking that into the data pipeline per-wiki would be kind of difficult, I think.

Anyway, I don't have an objection to having the API provide a more "raw" view of the data available, I just think that for product purposes, it would be hard to use that to reproduce the existing filtered, curated list of results that we get by combining ElasticSearch hasrecommendation:image keyword alongside various other search filters.

Re-implementing that feature set in the image suggestion API seems like a lot of extra work, IMHO.

For Growth features, we make use of community-defined lists of templates (see https://es.wikipedia.org/wiki/MediaWiki:NewcomerTasks.json and https://es.wikipedia.org/wiki/MediaWiki:GrowthExperimentsConfig.json) to, for example, prevent users from seeing image recommendations for articles that have infoboxes (see GEInfoboxTemplates in /MediaWiki:GrowthExperimentsConfig.json). Since each community would have different templates to list there, baking that into the data pipeline per-wiki would be kind of difficult, I think.

Yeah, sorry, I misunderstood how hastemplatecollection works (hadn't realised that it populates the collection from the wiki config). Looking at the code again I see now that we can't push it into the pipeline

... and now I also see why you were suggesting that Growth write an api - in fact afaics with the wiki-specific config there's no other way to supply articles-with-suggestions to the apps. If we wanted to keep everything in one place from the client perspective the api platform could provide a facade for Growth's api, but that would be all

...for product purposes, it would be hard to use that to reproduce the existing filtered, curated list of results that we get by combining ElasticSearch hasrecommendation:image keyword alongside various other search filters

...afaics with the wiki-specific config there's no other way to supply articles-with-suggestions to the apps. If we wanted to keep everything in one place from the client perspective the api platform could provide a facade for Growth's api, but that would be all

This is correct - ideally we would like to get the fully-curated list of article candidates, which sounds like it involves not just elasticsearch, but numerous per-wiki filters. Does this mean we'd need to consider pursuing something like T320739?

...for product purposes, it would be hard to use that to reproduce the existing filtered, curated list of results that we get by combining ElasticSearch hasrecommendation:image keyword alongside various other search filters

...afaics with the wiki-specific config there's no other way to supply articles-with-suggestions to the apps. If we wanted to keep everything in one place from the client perspective the api platform could provide a facade for Growth's api, but that would be all

This is correct - ideally we would like to get the fully-curated list of article candidates, which sounds like it involves not just elasticsearch, but numerous per-wiki filters. Does this mean we'd need to consider pursuing something like T320739?

Maybe. So, now that the picture is coming more into focus, I think you could use the growthtasks API module via MediaWiki's action API. Example query on Czech wiki https://cs.wikipedia.org/wiki/Speci%C3%A1ln%C3%AD:API_p%C3%ADskovi%C5%A1t%C4%9B#action=query&format=json&prop=&list=&generator=growthtasks&formatversion=2&ggttasktypes=image-recommendation

From your side, you'd want to keep track of the page IDs that this API returns to your app, and exclude them if you are paging through results (example of how we are doing this in the client-side code for Suggested Edits module on Special:Homepage https://github.com/wikimedia/mediawiki-extensions-GrowthExperiments/blob/e1fbda65f94a89422cc3860aadaca785bb9b130d/modules/ext.growthExperiments.DataStore/GrowthTasksApi.js#L133). That's because we don't have proper pagination of ElasticSearch results, as we are using a random sort.

From our side, we'd need to adjust the logic that allows you to reset the cached results. We currently do this on the server-side, when a user is visiting Special:Homepage, but since you're using the API endpoint exclusively, the cache refresh never happens.

The last point is that you need to be able to query the Cassandra dataset for the image suggestion details, and that either involves this task (make that API public) or proxy the access via GrowthExperiments (T320739).

The last point is that you need to be able to query the Cassandra dataset for the image suggestion details, and that either involves this task (make that API public) or proxy the access via GrowthExperiments (T320739).

Ok so if Android uses the growthtasks module of the MW action api, then really all this ticket needs to cover is

  • GET /suggestions/<wiki>/<page_id>
  • POST /suggestions/feedback

(I think the title_cache and instanceof_cache are unlikely to be needed by Android)

The last point is that you need to be able to query the Cassandra dataset for the image suggestion details, and that either involves this task (make that API public) or proxy the access via GrowthExperiments (T320739).

Ok so if Android uses the growthtasks module of the MW action api, then really all this ticket needs to cover is

  • GET /suggestions/<wiki>/<page_id>
  • POST /suggestions/feedback

(I think the title_cache and instanceof_cache are unlikely to be needed by Android)

I commented in the doc but I am not sure we need a POST endpoint for suggestions/feedback. I think that the Android team could make use of the growthinvalidateimagerecommendation API module. That handles:

  • invalidating the recommendation, and removing from search index
  • providing feedback to the caller if the user has exceeded the per-wiki daily limit on image recommendations
  • recording a log entry in Special:Log
  • Refreshing the user's cached TaskSet of image suggestions, if the client calls the API to get image suggestion recommendations again

can EventGate accept events from a non-MediaWiki service that lives within our network?

Yes!

which EventGate?

If internal to our network, and this is for non-analytics (production service) data, use eventgate-main. If you are using MediaWiki to produce, you can do this by depending on the EventBus extension and using it as a library. If you decide to do this, let me know and lets discuss more. I'm trying to refactor some things there and improve docs.

If external (e.g. from Android app itself), then we do not currently have a public facing eventgate service for you. We'd need to make an eventgate-main-external service. Doing this might require more discussion, as there is no authentication available for eventgate ATM, and exposing an eventgate that produces to the main Kafka cluster that is also used for JobQueue, etc. could be a little risky.

(BTW, it is not required to use EventGate to produce events to Kafka. EventGate is just an HTTP proxy. However, if you do produce to Kafka directly there's a bunch of integration bits your client code should do, like validate the event, etc etc. Basically everything listed here. We have a Java library that does this if you want to produce to Kafka from a Java service, but if you're not in Java, you'd have to write these bits yourselves.)

Change 850497 had a related patch set uploaded (by Kosta Harlan; author: Kosta Harlan):

[mediawiki/extensions/GrowthExperiments@master] Add ApiQueryImageSuggestionData prop module

https://gerrit.wikimedia.org/r/850497

Change 850497 had a related patch set uploaded (by Kosta Harlan; author: Kosta Harlan):

[mediawiki/extensions/GrowthExperiments@master] Add ApiQueryImageSuggestionData prop module

https://gerrit.wikimedia.org/r/850497

@Eevans @lbowmaker @BPirkle this patch proposes to add a prop API module that allows callers to get image suggestion data for titles. It looks like this (note: I am running an SSH tunnel locally, which is why these queries work for me ssh -N mwmaint1002.eqiad.wmnet -L 30443:image-suggestion.discovery.wmnet:30443):

apiimagesuggestiondata.gif (798×1 px, 1 MB)

Notes on the implementation in the patch:

  • it's limited to authenticated users
  • the module invokes PingLimiter, though we haven't proposed any default limits for the growthexperiments-apiqueryimagesuggestiondata action. Feedback welcome on that.
  • titles specified in the API request are validated ( $this->getPageSet()->getGoodPages() )
  • the data returned from Cassandra is added as-is to the API response
  • the calls to Cassandra are cached for 5 minutes, so e.g. if a user requests the growthimagesuggestionsdata prop for Foo, subsequent requests within the next 5 minutes for that title will go to WANObjectCache
  • There is a feature flag (GEApiQueryImageSuggestionDataEnabled) that provides an "off-switch" in case there are some issues with this prop module.

AIUI, we would like for someone from Platform (@Eevans, @lbowmaker, @DAbad?) and someone from SRE (@akosiaris?) to sign off on this before we enable this code in production.

AIUI, we would like for someone from Platform (@Eevans, @lbowmaker, @DAbad?) and someone from SRE (@akosiaris?) to sign off on this before we enable this code in production.

Hugh, Virginia, and I discussed this. There are no objections from our portion of Platform. While this wasn't where we expected the implementation to end up, after further discussion it makes the most sense. Thanks for putting it together.

In T306349#8382132, @kostajh wrote:
AIUI, we would like for someone from Platform (@Eevans, @lbowmaker, @DAbad?) and someone from SRE (@akosiaris?) to sign off on this before we enable this code in production.

Hi @VirginiaPoundstone do you have an estimation for timing for the above? Also have we confirmed who is doing what in terms of signoff and implementation? Thanks!

@LGoto this has API Platform sign off (via Bill's comment above).
@DAbad good to advance with the Extension solution? Not sure who from SRE needs to approve.

@LGoto this has API Platform sign off (via Bill's comment above).
@DAbad good to advance with the Extension solution? Not sure who from SRE needs to approve.

Adding SRE and serviceops tags.

Hi everyone, as I understand it, the public API for this service isn't just using the service itself, but rather the service (image-suggestion) is used as a backend for the mediawiki Growth Experiments extension, that adds RBAC and business logic on top of it.

Then in my opinion the public API should be indeed managed by the Growth Experiments extension and be part of the mediawiki REST API.

AIUI https://gerrit.wikimedia.org/r/c/mediawiki/extensions/GrowthExperiments/+/850497 is more or less doing exactly that. Am I correct?

Wiring this public-facing API into the api gateway should then be a separate, independent/optional process I think.

In terms of being able to interact with the production service for debugging / integration purposes, I see three possible solutions:

  • Local minikube - run the service, and a backend cassandra with some data locally
  • ssh tunnel - as @kostajh was indicating above, ssh tunnel to the staging environment
  • We add an auth-protected transparent proxy to all services somewhere

The first two solutions already exist and should be working already, the third would need some work from SRE to be set up; but allowing developers to access production services directly for dev purposes is a completely separated task and should be treated separately from exposing a public API.

@LGoto this has API Platform sign off (via Bill's comment above).
@DAbad good to advance with the Extension solution? Not sure who from SRE needs to approve.

I don't think explicit SRE approval is needed to proceed with the deployment of an Extension, for what is worth. We don't want to be blockers to deployments, quite the contrary. But we definitely do appreciate being kept in the loop so we can raise concerns.

I 've removed SRE as the more specific serviceops tag should suffice.

From a product perspective, ok with advancing with the extension solution.

Do we have an ETA for when this will be implemented?

Per @DMburugu, I believe @Tgr is the point person from Growth team for making this happen. As I understand it, the next step is merging https://gerrit.wikimedia.org/r/c/850497 and then doing T322309: Create API module for image recommendation rejections, there might be some other subtasks for this related to e.g. writing documentation.

kostajh renamed this task from Public-facing API for image suggestions data to Public-facing API for querying image suggestion recommendations and submitting user feedback.Dec 7 2022, 12:07 PM

@KStoller-WMF re: Kosta's previous comment, do you know when the Growth team will be able to complete this work? The Android team is hoping for an ETA so they can plan their own work around this. Thanks!

@LGoto it sounds like we can start this work soon and that it shouldn't be a major effort. It simply hasn't been prioritized because we have so many other priorities and this one didn't have a deadline attached. So actually if you let us know when you need this by, we can likely make that happen. What would be the ideal timeline for the Android team?

@KStoller-WMF Thanks! Having it by mid February would be ideal. (Worst case, by end of March.)

@LGoto @Dbrant AIUI based on T320739#8364915 these are the things you'd need from us by mid-February:

Please let us know if that's correct or I missed something.

@Tgr That sounds accurate, thanks!

I believe this one would be nice to have, but not a blocker for us.

Change 850497 merged by jenkins-bot:

[mediawiki/extensions/GrowthExperiments@master] Add ApiQueryImageSuggestionData prop module

https://gerrit.wikimedia.org/r/850497

@CBogen , @KStoller-WMF, @Tgr This has been merged. Can I mark it as resolved, if not, can I untag the API Platform team?

As discussed on Slack, while we do now have a solution that will allow the apps to implement the feature, we don't have a real public-facing API. I hope this will stay open and get prioritized in the future.

VirginiaPoundstone lowered the priority of this task from Medium to Low.Apr 26 2023, 12:29 PM