most-client 1.0.36__py3-none-any.whl → 1.0.38__py3-none-any.whl

most/__init__.py

@@ -2,3 +2,6 @@ from .api import MostClient
 from .async_api import AsyncMostClient
 from .trainer_api import Trainer
 from .async_trainer_api import AsyncTrainer
+from .searcher import MostSearcher
+from .async_searcher import AsyncMostClient
+from .search_types import SearchParams, IDCondition, ChannelsCondition, DurationCondition, ResultsCondition, StoredInfoCondition

most/api.py

@@ -18,14 +18,14 @@ from most.types import (
     Script,
     StoredAudioData,
     Text,
-    is_valid_id, SearchParams, ScriptScoreMapping, Dialog, Usage,
+    is_valid_id, ScriptScoreMapping, Dialog, Usage,
 )
 
 
 class MostClient(object):
     retort = Retort(recipe=[
-        loader(int, lambda x: int(x)),
-        loader(float, lambda x: float(x)),
+        loader(int, lambda x: x if isinstance(x, int) else int(x)),
+        loader(float, lambda x: x if isinstance(x, float) else float(x)),
         loader(datetime, lambda x: datetime.fromtimestamp(x).astimezone(tz=timezone.utc) if isinstance(x, (int, float)) else datetime.fromisoformat(x)),
     ],)
 
@@ -264,7 +264,7 @@ class MostClient(object):
                          params={"overwrite": overwrite})
         result = self.retort.load(resp.json(), Result)
         if modify_scores:
-            result = self.score_modifier.modify(result)
+            result = self.get_score_modifier().modify(result)
         return result
 
     def apply_on_text(self, text_id,
@@ -280,7 +280,7 @@ class MostClient(object):
                          params={"overwrite": overwrite})
         result = self.retort.load(resp.json(), Result)
         if modify_scores:
-            result = self.score_modifier.modify(result)
+            result = self.get_score_modifier().modify(result)
         return result
 
     def transcribe_later(self, audio_id,
@@ -308,7 +308,7 @@ class MostClient(object):
                          params={"overwrite": overwrite})
         result = self.retort.load(resp.json(), Result)
         if modify_scores:
-            result = self.score_modifier.modify(result)
+            result = self.get_score_modifier().modify(result)
         return result
 
     def apply_on_text_later(self, text_id,
@@ -324,7 +324,7 @@ class MostClient(object):
                          params={"overwrite": overwrite})
         result = self.retort.load(resp.json(), Result)
         if modify_scores:
-            result = self.score_modifier.modify(result)
+            result = self.get_score_modifier().modify(result)
         return result
 
     def get_job_status(self, audio_id) -> JobStatus:
@@ -348,7 +348,7 @@ class MostClient(object):
         resp = self.get(f"/{self.client_id}/audio/{audio_id}/model/{self.model_id}/results")
         result = self.retort.load(resp.json(), Result)
         if modify_scores:
-            result = self.score_modifier.modify(result)
+            result = self.get_score_modifier().modify(result)
         return result
 
     def fetch_text(self, audio_id: str) -> Result:
@@ -384,7 +384,8 @@ class MostClient(object):
 
     def export(self, audio_ids: List[str],
                aggregated_by: Optional[str] = None,
-               aggregation_title: Optional[str] = None) -> str:
+               aggregation_title: Optional[str] = None,
+               modify_scores: bool = False) -> str:
         if aggregation_title is None:
             aggregation_title = aggregated_by
 
@@ -394,12 +395,13 @@ class MostClient(object):
         resp = self.get(f"/{self.client_id}/model/{self.model_id}/export",
                         params={'audio_ids': ','.join(audio_ids),
                                 'aggregated_by': aggregated_by,
-                                'aggregation_title': aggregation_title})
+                                'aggregation_title': aggregation_title,
+                                'modify_scores': modify_scores})
         return resp.url
 
     def store_info(self,
                    audio_id: str,
-                   data: Dict[str, str]):
+                   data: Dict[str, Union[str, int, float]]) -> StoredAudioData:
         if not is_valid_id(audio_id):
             raise RuntimeError("Please use valid audio_id. [try audio.id from list_audios()]")
 
@@ -407,14 +409,14 @@ class MostClient(object):
                          json={
                              "data": data,
                          })
-        return self.retort.load(resp.json(), StoredAudioData)
+        return StoredAudioData.from_dict(resp.json())
 
-    def fetch_info(self, audio_id: str) -> Dict[str, str]:
+    def fetch_info(self, audio_id: str) -> StoredAudioData:
         if not is_valid_id(audio_id):
             raise RuntimeError("Please use valid audio_id. [try audio.id from list_audios()]")
 
         resp = self.get(f"/{self.client_id}/audio/{audio_id}/info")
-        return self.retort.load(resp.json(), StoredAudioData)
+        return StoredAudioData.from_dict(resp.json())
 
     def __call__(self, audio_path: Path,
                  modify_scores: bool = False) -> Result:
@@ -446,21 +448,6 @@ class MostClient(object):
             raise RuntimeError("Audio can't be indexed")
         return None
 
-    def search(self,
-               query: str,
-               filter: SearchParams,
-               limit: int = 10) -> List[Audio]:
-        resp = self.post(f"/{self.client_id}/model/{self.model_id}/search",
-                         json={
-                             "query": query,
-                             "filter": filter.to_dict(),
-                             "limit": limit,
-                         })
-        if resp.status_code >= 400:
-            raise RuntimeError("Audio can't be indexed")
-        audio_list = resp.json()
-        return self.retort.load(audio_list, List[Audio])
-
     def get_usage(self,
                   start_dt: datetime,
                   end_dt: datetime):

most/async_api.py

@@ -18,14 +18,14 @@ from most.types import (
     Script,
     StoredAudioData,
     Text,
-    is_valid_id, SearchParams, ScriptScoreMapping, Dialog, Usage,
+    is_valid_id, ScriptScoreMapping, Dialog, Usage,
 )
 
 
 class AsyncMostClient(object):
     retort = Retort(recipe=[
-        loader(int, lambda x: int(x)),
-        loader(float, lambda x: float(x)),
+        loader(int, lambda x: x if isinstance(x, int) else int(x)),
+        loader(float, lambda x: x if isinstance(x, float) else float(x)),
         loader(datetime, lambda x: datetime.fromtimestamp(x).astimezone(tz=timezone.utc) if isinstance(x, (int, float)) else datetime.fromisoformat(x)),
     ])
 
@@ -274,7 +274,8 @@ class AsyncMostClient(object):
                                params={"overwrite": overwrite})
         result = self.retort.load(resp.json(), Result)
         if modify_scores:
-            result = self.score_modifier.modify(result)
+            score_modifier = await self.get_score_modifier()
+            result = score_modifier.modify(result)
         return result
 
     async def apply_on_text(self, text_id,
@@ -290,7 +291,8 @@ class AsyncMostClient(object):
                                params={"overwrite": overwrite})
         result = self.retort.load(resp.json(), Result)
         if modify_scores:
-            result = self.score_modifier.modify(result)
+            score_modifier = await self.get_score_modifier()
+            result = score_modifier.modify(result)
         return result
 
     async def transcribe_later(self, audio_id,
@@ -318,7 +320,8 @@ class AsyncMostClient(object):
                                params={"overwrite": overwrite})
         result = self.retort.load(resp.json(), Result)
         if modify_scores:
-            result = self.score_modifier.modify(result)
+            score_modifier = await self.get_score_modifier()
+            result = score_modifier.modify(result)
         return result
 
     async def apply_on_text_later(self, text_id,
@@ -334,7 +337,8 @@ class AsyncMostClient(object):
                                params={"overwrite": overwrite})
         result = self.retort.load(resp.json(), Result)
         if modify_scores:
-            result = self.score_modifier.modify(result)
+            score_modifier = await self.get_score_modifier()
+            result = score_modifier.modify(result)
         return result
 
     async def get_job_status(self, audio_id) -> JobStatus:
@@ -358,7 +362,8 @@ class AsyncMostClient(object):
         resp = await self.get(f"/{self.client_id}/audio/{audio_id}/model/{self.model_id}/results")
         result = self.retort.load(resp.json(), Result)
         if modify_scores:
-            result = self.score_modifier.modify(result)
+            score_modifier = await self.get_score_modifier()
+            result = score_modifier.modify(result)
         return result
 
     async def fetch_text(self, audio_id) -> Result:
@@ -394,7 +399,8 @@ class AsyncMostClient(object):
 
     async def export(self, audio_ids: List[str],
                      aggregated_by: Optional[str] = None,
-                     aggregation_title: Optional[str] = None) -> str:
+                     aggregation_title: Optional[str] = None,
+                     modify_scores: bool = False) -> str:
         if aggregation_title is None:
             aggregation_title = aggregated_by
 
@@ -404,23 +410,24 @@ class AsyncMostClient(object):
         resp = await self.get(f"/{self.client_id}/model/{self.model_id}/export",
                               params={'audio_ids': ','.join(audio_ids),
                                       "aggregated_by": aggregated_by,
-                                      "aggregation_title": aggregation_title})
+                                      "aggregation_title": aggregation_title,
+                                      "modify_scores": modify_scores})
         return resp.next_request.url
 
     async def store_info(self,
                          audio_id: str,
-                         data: Dict[str, str]):
+                         data: Dict[str, Union[str, int, float]]) -> StoredAudioData:
         resp = await self.post(f"/{self.client_id}/audio/{audio_id}/info",
                                json={
                                    "data": data,
                                })
-        return self.retort.load(resp.json(), StoredAudioData)
+        return StoredAudioData.from_dict(resp.json())
 
-    async def fetch_info(self, audio_id: str) -> Dict[str, str]:
+    async def fetch_info(self, audio_id: str) -> StoredAudioData:
         if not is_valid_id(audio_id):
             raise RuntimeError("Please use valid audio_id. [try audio.id from list_audios()]")
         resp = await self.get(f"/{self.client_id}/audio/{audio_id}/info")
-        return self.retort.load(resp.json(), StoredAudioData)
+        return StoredAudioData.from_dict(resp.json())
 
     async def __call__(self, audio_path: Path,
                        modify_scores: bool = False) -> Result:
@@ -452,21 +459,6 @@ class AsyncMostClient(object):
             raise RuntimeError("Audio can't be indexed")
         return None
 
-    async def search(self,
-                     query: str,
-                     filter: SearchParams,
-                     limit: int = 10) -> List[Audio]:
-        resp = await self.post(f"/{self.client_id}/model/{self.model_id}/search",
-                               json={
-                                   "query": query,
-                                   "filter": filter.to_dict(),
-                                   "limit": limit,
-                               })
-        if resp.status_code >= 400:
-            raise RuntimeError("Audio can't be indexed")
-        audio_list = resp.json()
-        return self.retort.load(audio_list, List[Audio])
-
     async def get_usage(self,
                         start_dt: datetime,
                         end_dt: datetime):

most/async_searcher.py

@@ -0,0 +1,57 @@
+from typing import List, Literal, Optional
+from . import AsyncMostClient
+from .types import Audio
+from .search_types import SearchParams
+
+
+class AsyncMostSearcher(object):
+    def __init__(self, client: AsyncMostClient,
+                 data_source: Literal["text", "audio"]):
+        self.client = client
+        self.data_source = data_source
+
+    async def count(self,
+                    filter: Optional[SearchParams] = None):
+        if filter is None:
+            filter = SearchParams()
+
+        resp = await self.client.get(f"/{self.client.client_id}/{self.data_source}/count",
+                                     params={
+                                         "filter": filter.to_json(),
+                                     })
+        if resp.status_code >= 400:
+            raise RuntimeError("Audio can't be indexed")
+        return resp.json()
+
+
+    async def distinct(self,
+                       key: str,
+                       filter: Optional[SearchParams] = None) -> List[str]:
+        """
+        Distinct values of key.
+        :param key: key should be stored in info (fetch_info, store_info)
+        :return:
+        """
+        if filter is None:
+            filter = SearchParams()
+        resp = await self.client.get(f"/{self.client.client_id}/{self.data_source}/distinct",
+                               params={"filter": filter.to_json(),
+                                       "key": key})
+        if resp.status_code >= 400:
+            raise RuntimeError("Key is not valid")
+        return resp.json()
+
+    async def search(self,
+                     filter: Optional[SearchParams] = None,
+                     limit: int = 10) -> List[Audio]:
+        if filter is None:
+            filter = SearchParams()
+        resp = await self.client.get(f"/{self.client.client_id}/{self.data_source}/search",
+                                     params={
+                                         "filter": filter.to_json(),
+                                         "limit": limit,
+                                     })
+        if resp.status_code >= 400:
+            raise RuntimeError("Audio can't be indexed")
+        audio_list = resp.json()
+        return self.client.retort.load(audio_list, List[Audio])

most/score_calculation.py

@@ -1,4 +1,4 @@
-from typing import Dict, Tuple, List, Optional
+from typing import Dict, Tuple, List, Optional, Literal
 from dataclasses_json import dataclass_json, DataClassJsonMixin
 from dataclasses import dataclass, replace
 from .types import Result, ScriptScoreMapping
@@ -25,3 +25,55 @@ class ScoreCalculation(DataClassJsonMixin):
                                                            subcolumn_result.score)
 
         return result
+
+    def unmodify(self, result: Optional[Result]):
+        score_mapping = {
+            (sm.column, sm.subcolumn, sm.to_score): sm.from_score
+            for sm in self.score_mapping
+        }
+        if result is None:
+            return None
+        result = replace(result)
+        for column_result in result.results:
+            for subcolumn_result in column_result.subcolumns:
+                subcolumn_result.score = score_mapping.get((column_result.name,
+                                                            subcolumn_result.name,
+                                                            subcolumn_result.score),
+                                                           subcolumn_result.score)
+
+        return result
+
+    def modify_single(self,
+                      column: str, subcolumn: str,
+                      from_score: int):
+        for sm in self.score_mapping:
+            if sm.column == column and sm.subcolumn == subcolumn and sm.from_score == from_score:
+                return sm.to_score
+
+    def unmodify_single(self,
+                        column: str, subcolumn: str,
+                        to_score: int,
+                        bound: Literal["strict", "upper", "lower"] = "strict"):
+        upper_from_score = None
+        lower_from_score = None
+
+        for sm in self.score_mapping:
+            if sm.column == column and sm.subcolumn == subcolumn:
+                if sm.to_score == to_score:
+                    return sm.from_score
+
+                if sm.to_score > to_score:
+                    if upper_from_score is None or sm.to_score < upper_from_score[1]:
+                        upper_from_score = (sm.from_score, sm.to_score)
+                elif sm.to_score < to_score:
+                    if lower_from_score is None or sm.to_score > lower_from_score[1]:
+                        lower_from_score = (sm.from_score, sm.to_score)
+
+        if bound == "strict":
+            return None
+        elif bound == "upper" and upper_from_score is not None:
+            return upper_from_score[0]
+        elif bound == "lower" and lower_from_score is not None:
+            return lower_from_score[0]
+        else:
+            return None

most/search_types.py

@@ -0,0 +1,143 @@
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from bson import ObjectId
+from dataclasses_json import DataClassJsonMixin, dataclass_json
+
+
+@dataclass_json
+@dataclass
+class IDCondition(DataClassJsonMixin):
+    equal: Optional[ObjectId] = None
+    in_set: Optional[List[ObjectId]] = None
+    greater_than: Optional[ObjectId] = None
+    less_than: Optional[ObjectId] = None
+
+
+@dataclass_json
+@dataclass
+class ChannelsCondition(DataClassJsonMixin):
+    equal: Optional[int] = None
+
+
+@dataclass_json
+@dataclass
+class DurationCondition(DataClassJsonMixin):
+    greater_than: Optional[int] = None
+    less_than: Optional[int] = None
+
+
+@dataclass_json
+@dataclass
+class StoredInfoCondition(DataClassJsonMixin):
+    key: str
+    match: Optional[int | str | float] = None
+    starts_with: Optional[str] = None
+    ends_with: Optional[str] = None
+    greater_than: Optional[int | str | float] = None
+    less_than: Optional[int | str | float] = None
+
+
+@dataclass_json
+@dataclass
+class ResultsCondition(DataClassJsonMixin):
+    column_idx: int
+    subcolumn_idx: int
+    model_id: str
+    score_equal: Optional[int] = None
+    score_in_set: Optional[List[int]] = None
+    score_greater_than: Optional[int] = None
+    score_less_than: Optional[int] = None
+
+    def create_from(self, client,
+                    column: str, subcolumn: str,
+                    score_equal: Optional[int] = None,
+                    score_in_set: Optional[List[int]] = None,
+                    score_greater_than: Optional[int] = None,
+                    score_less_than: Optional[int] = None,
+                    modified_scores: bool = False) -> 'ResultsCondition':
+        from .api import MostClient
+        client: MostClient
+        script = client.get_model_script()
+        column_idx = [column.name for column in script.columns].index(column)
+        subcolumn_idx = script.columns[column_idx].subcolumns.index(subcolumn)
+
+        if modified_scores:
+            score_modifier = client.get_score_modifier()
+            if score_equal is not None:
+                score_equal = score_modifier.unmodify_single(column, subcolumn,
+                                                             score_equal,
+                                                             bound="strict")
+            if score_in_set is not None:
+                score_in_set = [score_modifier.unmodify_single(column, subcolumn,
+                                                               score,
+                                                               bound="strict")
+                                for score in score_in_set]
+            if score_greater_than is not None:
+                score_greater_than = score_modifier.unmodify_single(column, subcolumn,
+                                                                    score_greater_than,
+                                                                    bound="upper")
+
+            if score_less_than is not None:
+                score_less_than = score_modifier.unmodify_single(column, subcolumn,
+                                                                 score_less_than,
+                                                                 bound="lower")
+
+        return ResultsCondition(model_id=client.model_id,
+                                column_idx=column_idx,
+                                subcolumn_idx=subcolumn_idx,
+                                score_equal=score_equal,
+                                score_in_set=score_in_set,
+                                score_greater_than=score_greater_than,
+                                score_less_than=score_less_than)
+
+    async def acreate_from(self, client,
+                           column: str, subcolumn: str,
+                           score_equal: Optional[int] = None,
+                           score_in_set: Optional[List[int]] = None,
+                           score_greater_than: Optional[int] = None,
+                           score_less_than: Optional[int] = None,
+                           modified_scores: bool = False) -> 'ResultsCondition':
+        from .async_api import AsyncMostClient
+        client: AsyncMostClient
+        script = await client.get_model_script()
+        column_idx = [column.name for column in script.columns].index(column)
+        subcolumn_idx = script.columns[column_idx].subcolumns.index(subcolumn)
+
+        if modified_scores:
+            score_modifier = await client.get_score_modifier()
+            if score_equal is not None:
+                score_equal = score_modifier.unmodify_single(column, subcolumn,
+                                                             score_equal,
+                                                             bound="strict")
+            if score_in_set is not None:
+                score_in_set = [score_modifier.unmodify_single(column, subcolumn,
+                                                               score,
+                                                               bound="strict")
+                                for score in score_in_set]
+            if score_greater_than is not None:
+                score_greater_than = score_modifier.unmodify_single(column, subcolumn,
+                                                                    score_greater_than,
+                                                                    bound="upper")
+
+            if score_less_than is not None:
+                score_less_than = score_modifier.unmodify_single(column, subcolumn,
+                                                                 score_less_than,
+                                                                 bound="lower")
+
+        return ResultsCondition(model_id=client.model_id,
+                                column_idx=column_idx,
+                                subcolumn_idx=subcolumn_idx,
+                                score_equal=score_equal,
+                                score_in_set=score_in_set,
+                                score_greater_than=score_greater_than,
+                                score_less_than=score_less_than)
+
+
+@dataclass_json
+@dataclass
+class SearchParams(DataClassJsonMixin):
+    must: List[StoredInfoCondition | ResultsCondition | DurationCondition | ChannelsCondition | IDCondition ] = field(default_factory=list)
+    should: List[StoredInfoCondition | ResultsCondition | DurationCondition | ChannelsCondition | IDCondition ] = field(default_factory=list)
+    must_not: List[StoredInfoCondition | ResultsCondition | DurationCondition | ChannelsCondition | IDCondition ] = field(default_factory=list)
+    should_not: List[StoredInfoCondition | ResultsCondition | DurationCondition | ChannelsCondition | IDCondition ] = field(default_factory=list)

most/searcher.py

@@ -0,0 +1,57 @@
+from typing import List, Literal, Optional
+
+from .api import MostClient
+from .search_types import SearchParams
+from .types import Audio, Text
+
+
+class MostSearcher(object):
+    def __init__(self, client: MostClient,
+                 data_source: Literal["text", "audio"]):
+        self.client = client
+        self.data_source = data_source
+
+    def count(self,
+              filter: Optional[SearchParams] = None):
+        if filter is None:
+            filter = SearchParams()
+
+        resp = self.client.get(f"/{self.client.client_id}/{self.data_source}/count",
+                               params={
+                                   "filter": filter.to_json(),
+                               })
+        if resp.status_code >= 400:
+            raise RuntimeError("Audio can't be indexed")
+        return resp.json()
+
+    def distinct(self,
+                 key: str,
+                 filter: Optional[SearchParams] = None) -> List[str]:
+        """
+        Distinct values of key.
+        :param key: key should be stored in info (fetch_info, store_info)
+        :return:
+        """
+        if filter is None:
+            filter = SearchParams()
+        resp = self.client.get(f"/{self.client.client_id}/{self.data_source}/distinct",
+                               params={"filter": filter.to_json(),
+                                       "key": key})
+        if resp.status_code >= 400:
+            raise RuntimeError("Key is not valid")
+        return resp.json()
+
+    def search(self,
+               filter: Optional[SearchParams] = None,
+               limit: int = 10) -> List[Audio | Text]:
+        if filter is None:
+            filter = SearchParams()
+        resp = self.client.get(f"/{self.client.client_id}/{self.data_source}/search",
+                                params={
+                                    "filter": filter.to_json(),
+                                    "limit": limit,
+                                })
+        if resp.status_code >= 400:
+            raise RuntimeError("Audio can't be indexed")
+        audio_list = resp.json()
+        return self.client.retort.load(audio_list, List[Audio])

most/types.py

@@ -2,7 +2,6 @@ import re
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Dict, List, Literal, Optional, Union
-
 from dataclasses_json import DataClassJsonMixin, dataclass_json
 
 
@@ -10,7 +9,7 @@ from dataclasses_json import DataClassJsonMixin, dataclass_json
 @dataclass
 class StoredAudioData(DataClassJsonMixin):
     id: str
-    data: Dict[str, str]
+    data: Dict[str, Union[str, int, float]]
 
 
 @dataclass_json
@@ -125,32 +124,6 @@ class DialogResult(DataClassJsonMixin):
     results: Optional[List[ColumnResult]] = None
 
 
-@dataclass_json
-@dataclass
-class StoredInfoCondition(DataClassJsonMixin):
-    key: str
-    match: Optional[str] = None
-    starts_with: Optional[str] = None
-    ends_with: Optional[str] = None
-
-
-@dataclass_json
-@dataclass
-class ResultsCondition(DataClassJsonMixin):
-    column: str
-    subcolumn: str
-    score_greater_than: Optional[int] = None
-    score_less_than: Optional[int] = None
-
-
-@dataclass_json
-@dataclass
-class SearchParams(DataClassJsonMixin):
-    must: List[StoredInfoCondition | ResultsCondition]
-    should: List[StoredInfoCondition | ResultsCondition]
-    must_not: List[StoredInfoCondition | ResultsCondition]
-
-
 @dataclass_json
 @dataclass
 class HumanFeedback(DataClassJsonMixin):

{most_client-1.0.36.dist-info → most_client-1.0.38.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: most-client
-Version: 1.0.36
+Version: 1.0.38
 Summary: Most AI API for https://the-most.ai
 Home-page: https://github.com/the-most-ai/most-client
 Author: George Kasparyants
@@ -27,6 +27,7 @@ Requires-Dist: tox
 Requires-Dist: twine
 Requires-Dist: httpx
 Requires-Dist: pydub
+Requires-Dist: bson
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

most_client-1.0.38.dist-info/RECORD

@@ -0,0 +1,16 @@
+most/__init__.py,sha256=yoPKMxjZYAzrVqZ7l9rN0Skh0HPuttPX7ub0wlZMby4,351
+most/_constrants.py,sha256=SlHKcBoXwe_sPzk8tdbb7lqhQz-Bfo__FhSoeFWodZE,217
+most/api.py,sha256=HmJSAwLVuy7uaeVAM3y1nd-F-UDZ2kOVww_i2EY0Sjs,19145
+most/async_api.py,sha256=Xyo1sGN4QstqIZh_4YDT6FStaXR0HRy6fbtbqc7uqK8,20562
+most/async_searcher.py,sha256=C0zViW20K7OhKO1BzBZktTbMJYBBvor3uK6LAHZTxz0,2238
+most/async_trainer_api.py,sha256=99rED8RjnOn8VezeEgrTgoVfQrO7DdmOE2Jajumno2g,1052
+most/score_calculation.py,sha256=vLtGqXrR43xZhGjrH5dpQZfWX1q3s74LvTaHn-SKBAg,3254
+most/search_types.py,sha256=63kBZvvkqlN2UOHXcxTraI9vEq-ANoqXmBnHi_QABDE,6729
+most/searcher.py,sha256=9UdiSlScsE6EPc6RpK8xkRLeB5gHNxgPQpXTJ17i3lQ,2135
+most/trainer_api.py,sha256=ZwOv4mhROfY97n6i7IY_ZpafsuNRazOqMBAf2dh708k,992
+most/types.py,sha256=AU74VqYilM9DXfBwptliRbhV5urLAf4BygdIY3wlAN8,4309
+most_client-1.0.38.dist-info/METADATA,sha256=17PN1v9-yRjWGMSVCEIlIKdkK7z6QQlFIaP9ZtvtQFU,1047
+most_client-1.0.38.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+most_client-1.0.38.dist-info/top_level.txt,sha256=2g5fk02LKkM1hV3pVVti_LQ60TToLBcR2zQ3JEKGVk8,5
+most_client-1.0.38.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+most_client-1.0.38.dist-info/RECORD,,

{most_client-1.0.36.dist-info → most_client-1.0.38.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.1)
+Generator: setuptools (80.4.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

most_client-1.0.36.dist-info/RECORD

@@ -1,13 +0,0 @@
-most/__init__.py,sha256=b0EXXaPA4kmt-FtGXKRWZr7SCwjipMLcpC6uT5WRIdY,144
-most/_constrants.py,sha256=SlHKcBoXwe_sPzk8tdbb7lqhQz-Bfo__FhSoeFWodZE,217
-most/api.py,sha256=vg7zYsRebQjVOmTLRQE6jqmK-zG1j-k-KMN68gzFpk4,19538
-most/async_api.py,sha256=iRIjHLVkrjBKimlVmz5Ev_pPNB0dwCa5QgKRy1rCF3c,20753
-most/async_trainer_api.py,sha256=99rED8RjnOn8VezeEgrTgoVfQrO7DdmOE2Jajumno2g,1052
-most/score_calculation.py,sha256=1XU1LfIH5LSCwAbAaKkr-EjH5qOTXrJKOUvhCCawka4,1054
-most/trainer_api.py,sha256=ZwOv4mhROfY97n6i7IY_ZpafsuNRazOqMBAf2dh708k,992
-most/types.py,sha256=KP34dzS8ayQUhToIxwxTL9O8-7TZz1ySfJzA3ZNGIGw,4921
-most_client-1.0.36.dist-info/METADATA,sha256=GnPH3grUAX3tLjJKswpB1_vDWtZ8i59zX0miAxZTRx8,1027
-most_client-1.0.36.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-most_client-1.0.36.dist-info/top_level.txt,sha256=2g5fk02LKkM1hV3pVVti_LQ60TToLBcR2zQ3JEKGVk8,5
-most_client-1.0.36.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-most_client-1.0.36.dist-info/RECORD,,