Include dedup info in get stamp

api/account/deduplication/lifo.py

@@ -1,10 +1,11 @@
 import copy
 from typing import Tuple
 
-import api_logging as logging
-from account.models import Community
 from django.conf import settings
 from django.db import IntegrityError
+
+import api_logging as logging
+from account.models import Community
 from registry.models import Event, HashScorerLink, Stamp
 from registry.utils import get_utc_time
 
@@ -128,8 +129,7 @@ async def arun_lifo_dedup(
                     for stamp in clashing_stamps
                 ]
             )
-
-    return (deduped_passport, None)
+    return (deduped_passport, None, clashing_stamps)
 
 
 async def save_hash_links(

api/account/test/test_deduplication_lifo.py

@@ -1,13 +1,14 @@
 from unittest import mock
 
-from account.deduplication import Rules
-from account.deduplication.lifo import HashScorerLinkIntegrityError, alifo
-from account.models import Account, Community
 from asgiref.sync import async_to_sync
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.test import TransactionTestCase
 from ninja_jwt.schema import RefreshToken
+
+from account.deduplication import Rules
+from account.deduplication.lifo import HashScorerLinkIntegrityError, alifo
+from account.models import Account, Community
 from registry.models import HashScorerLink, Passport, Stamp
 from scorer_weighted.models import Scorer, WeightedScorer
 
@@ -83,7 +84,7 @@ async def test_lifo_no_deduplicate_across_cummunities(self):
             credential=credential,
         )
 
-        deduped_passport, _ = await alifo(
+        deduped_passport, _, _ = await alifo(
             passport1.community, {"stamps": [credential]}, passport1.address
         )
 
@@ -121,7 +122,7 @@ async def test_lifo_no_deduplicate_same_passport_address_across_cummunities(self
             credential=credential,
         )
 
-        deduped_passport, _ = await alifo(
+        deduped_passport, _, _ = await alifo(
             passport1.community, {"stamps": [credential]}, passport1.address
         )
 
@@ -140,7 +141,7 @@ async def test_lifo_deduplicate(self):
         )
 
         # We test deduplication of the 1st passport (for example user submits the same passport again)
-        deduped_passport, _ = await alifo(
+        deduped_passport, _, _ = await alifo(
             passport.community, {"stamps": [credential]}, passport.address
         )
 
@@ -157,7 +158,7 @@ async def test_lifo_deduplicate(self):
 
         # We test deduplication of another passport with different address but
         # with the same stamp
-        deduped_passport, _ = await alifo(
+        deduped_passport, _, _ = await alifo(
             passport.community, {"stamps": [credential]}, "0xaddress_2"
         )
 

api/ceramic_cache/test/test_cmd_scorer_dump_data.py

@@ -95,6 +95,7 @@ def upload_file(self, file_name, *args, **kwargs):
             "error",
             "evidence",
             "stamp_scores",
+            "stamps",
             "id",
         }
         expected_passport_keys = {"address", "community", "requires_calculation"}

api/registry/atasks.py

@@ -87,7 +87,12 @@ async def aload_passport_data(address: str) -> Dict:
     return passport_data
 
 
-async def acalculate_score(passport: Passport, community_id: int, score: Score):
+async def acalculate_score(
+    passport: Passport,
+    community_id: int,
+    score: Score,
+    clashing_stamps: list[dict] = [],
+):
     log.debug("Scoring")
     user_community = await Community.objects.aget(pk=community_id)
 
@@ -104,6 +109,32 @@ async def acalculate_score(passport: Passport, community_id: int, score: Score):
     score.error = None
     score.stamp_scores = scoreData.stamp_scores
     score.expiration_date = scoreData.expiration_date
+    stamps = {}
+    for stamp_name, stamp_score in scoreData.stamp_scores.items():
+        # Find if the stamp_name matches any provider in clashing_stamps
+        matching_stamp = next(
+            (stamp for stamp in clashing_stamps if stamp_name == stamp["provider"]),
+            None,
+        )
+
+        # Construct the stamps dictionary
+        stamps[stamp_name] = {
+            "score": str(stamp_score),
+            "dedup": matching_stamp is not None,
+            "expiration_date": matching_stamp["credential"]["expirationDate"]
+            if matching_stamp
+            else scoreData.expiration_dates[stamp_name].isoformat(),
+        }
+    # Add stamps present in clashing_stamps but not in stamp_scores
+    for c_stamp in clashing_stamps:
+        provider_name = c_stamp["provider"]
+        if provider_name not in stamps:
+            stamps[provider_name] = {
+                "score": "0",  # Default score for stamps not in stamp_scores
+                "dedup": True,
+                "expiration_date": c_stamp["credential"]["expirationDate"],
+            }
+    score.stamps = stamps
     log.info("Calculated score: %s", score)
 
 
@@ -126,7 +157,7 @@ async def aprocess_deduplication(passport, community, passport_data, score: Scor
     if not method:
         raise Exception("Invalid rule")
 
-    deduplicated_passport, affected_passports = await method(
+    deduplicated_passport, affected_passports, clashing_stamps = await method(
         community, passport_data, passport.address
     )
 
@@ -151,7 +182,7 @@ async def aprocess_deduplication(passport, community, passport_data, score: Scor
     #         await acalculate_score(passport, passport.community_id, affected_score)
     #         await affected_score.asave()
 
-    return deduplicated_passport
+    return (deduplicated_passport, clashing_stamps)
 
 
 async def avalidate_credentials(passport: Passport, passport_data) -> dict:
@@ -223,12 +254,12 @@ async def ascore_passport(
     try:
         passport_data = await aload_passport_data(address)
         validated_passport_data = await avalidate_credentials(passport, passport_data)
-        deduped_passport_data = await aprocess_deduplication(
+        (deduped_passport_data, clashing_stamps) = await aprocess_deduplication(
             passport, community, validated_passport_data, score
         )
         await asave_stamps(passport, deduped_passport_data)
         await aremove_stale_stamps_from_db(passport, deduped_passport_data)
-        await acalculate_score(passport, community.pk, score)
+        await acalculate_score(passport, community.pk, score, clashing_stamps)
 
     except APIException as e:
         log.error(

api/registry/migrations/0042_score_stamps.py

@@ -0,0 +1,17 @@
+# Generated by Django 4.2.6 on 2024-11-28 20:07
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("registry", "0041_weightconfiguration_description"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="score",
+            name="stamps",
+            field=models.JSONField(blank=True, null=True),
+        ),
+    ]

api/registry/models.py

@@ -80,6 +80,7 @@ class Status:
     error = models.TextField(null=True, blank=True)
     evidence = models.JSONField(null=True, blank=True)
     stamp_scores = models.JSONField(null=True, blank=True)
+    stamps = models.JSONField(null=True, blank=True)
 
     expiration_date = models.DateTimeField(
         default=None, null=True, blank=True, db_index=True

api/registry/test/test_passport_get_score.py

@@ -1,12 +1,12 @@
 import datetime
+from urllib.parse import urlencode
 
 import pytest
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import Group
 from django.test import Client
 from web3 import Web3
-from urllib.parse import urlencode
 
 from account.models import Account, AccountAPIKey, Community
 from registry.api.v1 import get_scorer_by_id

api/scorer/config/gitcoin_passport_weights.py

@@ -33,6 +33,7 @@
     "IdenaState#Verified": "2.029",
     "Lens": "0.93",
     "Linkedin": "1.531",
+    "LinkedinV2": "1.531",
     "NFT": "1.032",
     "NFTScore#50": "10.033",
     "NFTScore#75": "2.034",

api/scorer/test/test_choose_binary_scorer.py

@@ -149,6 +149,7 @@ def _(scorer_community_with_binary_scorer, scorer_api_key):
                 "sum_of_weights": Decimal("70"),
                 "earned_points": {},
                 "expiration_date": datetime.now(timezone.utc),
+                "expiration_dates": {},
             }
         ],
     ):
@@ -220,6 +221,7 @@ def _(scorer_community_with_binary_scorer, scorer_api_key):
                     "sum_of_weights": Decimal("90"),
                     "earned_points": {},
                     "expiration_date": datetime.now(timezone.utc),
+                    "expiration_dates": {},
                 }
             ],
         ):

api/scorer_weighted/computation.py

@@ -1,11 +1,12 @@
+from datetime import datetime
 from decimal import Decimal
+from math import e
 from typing import Dict, List
 
 import api_logging as logging
+from account.models import Customization
 from registry.models import Stamp
 from scorer_weighted.models import WeightedScorer
-from account.models import Customization
-from datetime import datetime
 
 log = logging.getLogger(__name__)
 
@@ -46,6 +47,7 @@ def calculate_weighted_score(
         scored_providers = []
         earned_points = {}
         earliest_expiration_date = None
+        expiration_dates = {}
         for stamp in Stamp.objects.filter(passport_id=passport_id):
             if stamp.provider not in scored_providers:
                 weight = Decimal(weights.get(stamp.provider, 0))
@@ -55,6 +57,7 @@ def calculate_weighted_score(
                 expiration_date = datetime.fromisoformat(
                     stamp.credential["expirationDate"]
                 )
+                expiration_dates[stamp.provider] = expiration_date
                 # Compute the earliest expiration date for the stamps used to calculate the score
                 # as this will be the expiration date of the score
                 if (
@@ -69,6 +72,7 @@ def calculate_weighted_score(
                 "sum_of_weights": sum_of_weights,
                 "earned_points": earned_points,
                 "expiration_date": earliest_expiration_date,
+                "expiration_dates": expiration_dates,
             }
         )
     return ret
@@ -95,6 +99,7 @@ def recalculate_weighted_score(
         scored_providers = []
         earned_points = {}
         earliest_expiration_date = None
+        expiration_dates = {}
         for stamp in stamp_list:
             if stamp.provider not in scored_providers:
                 weight = Decimal(weights.get(stamp.provider, 0))
@@ -104,6 +109,7 @@ def recalculate_weighted_score(
                 expiration_date = datetime.fromisoformat(
                     stamp.credential["expirationDate"]
                 )
+                expiration_dates[stamp.provider] = expiration_date
                 # Compute the earliest expiration date for the stamps used to calculate the score
                 # as this will be the expiration date of the score
                 if (
@@ -118,6 +124,7 @@ def recalculate_weighted_score(
                 "sum_of_weights": sum_of_weights,
                 "earned_points": earned_points,
                 "expiration_date": earliest_expiration_date,
+                "expiration_dates": expiration_dates,
             }
         )
     return ret
@@ -158,6 +165,7 @@ async def acalculate_weighted_score(
         sum_of_weights: Decimal = Decimal(0)
         scored_providers = []
         earned_points = {}
+        expiration_dates = {}
         earliest_expiration_date = None
         async for stamp in Stamp.objects.filter(passport_id=passport_id):
             if stamp.provider not in scored_providers:
@@ -168,6 +176,7 @@ async def acalculate_weighted_score(
                 expiration_date = datetime.fromisoformat(
                     stamp.credential["expirationDate"]
                 )
+                expiration_dates[stamp.provider] = expiration_date
                 # Compute the earliest expiration date for the stamps used to calculate the score
                 # as this will be the expiration date of the score
                 if (
@@ -183,6 +192,7 @@ async def acalculate_weighted_score(
                 "sum_of_weights": sum_of_weights,
                 "earned_points": earned_points,
                 "expiration_date": earliest_expiration_date,
+                "expiration_dates": expiration_dates,
             }
         )
     return ret

api/scorer_weighted/models.py

@@ -44,11 +44,13 @@ def __init__(
         evidence: Optional[List[ThresholdScoreEvidence]],
         points: dict,
         expiration_date: datetime,
+        expiration_dates: dict,
     ):
         self.score = score
         self.evidence = evidence
         self.stamp_scores = points
         self.expiration_date = expiration_date
+        self.expiration_dates = expiration_dates
 
     def __repr__(self):
         return f"ScoreData(score={self.score}, evidence={self.evidence})"
@@ -125,6 +127,7 @@ def recompute_score(
                 evidence=None,
                 points=s["earned_points"],
                 expiration_date=s["expiration_date"],
+                expiration_dates=s["expiration_dates"],
             )
             for s in recalculate_weighted_score(
                 self, passport_ids, stamps, community_id
@@ -145,6 +148,7 @@ async def acompute_score(self, passport_ids, community_id: int) -> List[ScoreDat
                 evidence=None,
                 points=s["earned_points"],
                 expiration_date=s["expiration_date"],
+                expiration_dates=s["expiration_dates"],
             )
             for s in scores
         ]
@@ -187,6 +191,7 @@ def compute_score(self, passport_ids, community_id: int) -> List[ScoreData]:
                     ],
                     points=rawScore["earned_points"],
                     expiration_date=rawScore["expiration_date"],
+                    expiration_dates=rawScore["expiration_dates"],
                 ),
                 rawScores,
                 binaryScores,
@@ -221,6 +226,7 @@ def recompute_score(
                     ],
                     points=rawScore["earned_points"],
                     expiration_date=rawScore["expiration_date"],
+                    expiration_dates=rawScore["expiration_dates"],
                 ),
                 rawScores,
                 binaryScores,
@@ -253,6 +259,7 @@ async def acompute_score(self, passport_ids, community_id: int) -> List[ScoreDat
                     ],
                     points=rawScore["earned_points"],
                     expiration_date=rawScore["expiration_date"],
+                    expiration_dates=rawScore["expiration_dates"],
                 ),
                 rawScores,
                 binaryScores,