logdetective 2.10.0__py3-none-any.whl → 2.12.0__py3-none-any.whl

logdetective/server/server.py

@@ -2,13 +2,17 @@ import os
 import asyncio
 import datetime
 from enum import Enum
+from collections import defaultdict
 from contextlib import asynccontextmanager
 from typing import Annotated
 from io import BytesIO
 
+from aiolimiter import AsyncLimiter
 import matplotlib
 import matplotlib.figure
 import matplotlib.pyplot
+from koji import ClientSession
+from gitlab import Gitlab
 from fastapi import (
     FastAPI,
     HTTPException,
@@ -18,12 +22,12 @@ from fastapi import (
     Path,
     Request,
 )
-
 from fastapi.responses import StreamingResponse
 from fastapi.responses import Response as BasicResponse
 import aiohttp
 import sentry_sdk
 
+from logdetective.extractors import DrainExtractor, CSGrepExtractor, Extractor
 from logdetective.server.exceptions import KojiInvalidTaskID
 
 from logdetective.server.database.models.koji import KojiTaskAnalysis
@@ -42,13 +46,14 @@ from logdetective.server.koji import (
 from logdetective.remote_log import RemoteLog
 from logdetective.server.llm import (
     perform_staged_analysis,
-    perfrom_analysis,
-    perform_analyis_stream,
+    perform_analysis,
+    perform_analysis_stream,
 )
 from logdetective.server.gitlab import process_gitlab_job_event
 from logdetective.server.metric import track_request, add_new_metrics, update_metrics
 from logdetective.server.models import (
     BuildLog,
+    Config,
     EmojiHook,
     JobHook,
     KojiInstanceConfig,
@@ -56,6 +61,7 @@ from logdetective.server.models import (
     Response,
     StagedResponse,
     TimePeriod,
+    ExtractorConfig,
 )
 from logdetective.server import plot as plot_engine
 from logdetective.server.database.models import (
@@ -78,6 +84,89 @@ if sentry_dsn := SERVER_CONFIG.general.sentry_dsn:
     sentry_sdk.init(dsn=str(sentry_dsn), traces_sample_rate=1.0)
 
 
+def initialize_extractors(extractor_config: ExtractorConfig) -> list[Extractor]:
+    """Set up extractors based on provided ExtractorConfig."""
+    extractors: list[Extractor] = [
+        DrainExtractor(
+            verbose=extractor_config.verbose,
+            max_snippet_len=extractor_config.max_snippet_len,
+            max_clusters=extractor_config.max_clusters,
+        )
+    ]
+
+    if extractor_config.csgrep:
+        extractors.append(
+            CSGrepExtractor(
+                verbose=extractor_config.verbose,
+                max_snippet_len=extractor_config.max_snippet_len,
+            )
+        )
+
+    return extractors
+
+
+class ConnectionManager:
+    """
+    Manager for all connections and sesssions.
+    """
+
+    koji_connections: dict[str, ClientSession] = {}
+    gitlab_connections: dict[str, Gitlab] = {}
+    gitlab_http_sessions: dict[str, aiohttp.ClientSession] = {}
+
+    async def initialize(self, service_config: Config):
+        """Initialize all managed objects"""
+
+        for connection, config in service_config.gitlab.instances.items():
+            self.gitlab_connections[connection] = Gitlab(
+                url=config.url,
+                private_token=config.api_token,
+                timeout=config.timeout,
+            )
+            self.gitlab_http_sessions[connection] = aiohttp.ClientSession(
+                base_url=config.url,
+                headers={"Authorization": f"Bearer {config.api_token}"},
+                timeout=aiohttp.ClientTimeout(
+                    total=config.timeout,
+                    connect=3.07,
+                ),
+            )
+        for connection, config in service_config.koji.instances.items():
+            self.koji_connections[connection] = ClientSession(baseurl=config.xmlrpc_url)
+
+    async def close(self):
+        """Close all managed http sessions"""
+        for session in self.gitlab_http_sessions.values():
+
+            await session.close()
+
+
+class KojiCallbackManager:
+    """Manages callbacks used by Koji, with callbacks referenced by task id.
+
+    Multiple callbacks can be assigned to a single task."""
+
+    _callbacks: defaultdict[int, set[str]]
+
+    def __init__(self) -> None:
+        self._callbacks = defaultdict(set)
+
+    def register_callback(self, task_id: int, callback: str):
+        """Register a callback for a task"""
+        self._callbacks[task_id].add(callback)
+
+    def clear_callbacks(self, task_id: int):
+        """Unregister a callback for a task"""
+        try:
+            del self._callbacks[task_id]
+        except KeyError:
+            pass
+
+    def get_callbacks(self, task_id: int) -> set[str]:
+        """Get the callbacks for a task"""
+        return self._callbacks[task_id]
+
+
 @asynccontextmanager
 async def lifespan(fapp: FastAPI):
     """
@@ -89,14 +178,31 @@ async def lifespan(fapp: FastAPI):
         )
     )
 
+    # General limiter for async requests
+    fapp.state.llm_request_limiter = AsyncLimiter(
+        max_rate=SERVER_CONFIG.inference.requests_per_minute
+    )
+
+    # Manager for connections and sessions
+    fapp.state.connection_manager = ConnectionManager()
+
+    await fapp.state.connection_manager.initialize(service_config=SERVER_CONFIG)
+
+    # Set up extractors
+    fapp.state.extractors = initialize_extractors(SERVER_CONFIG.extractor)
+
+    # Koji callbacks
+    fapp.state.koji_callback_manager = KojiCallbackManager()
+
     # Ensure that the database is initialized.
     await logdetective.server.database.base.init()
 
     # Start the background task scheduler for collecting emojis
-    asyncio.create_task(schedule_collect_emojis_task())
+    asyncio.create_task(schedule_collect_emojis_task(fapp.state.connection_manager))
 
     yield
 
+    await fapp.state.connection_manager.close()
     await fapp.http.close()
 
 
@@ -144,20 +250,24 @@ app = FastAPI(
     contact={
         "name": "Log Detective developers",
         "url": "https://github.com/fedora-copr/logdetective",
-        "email": "copr-devel@lists.fedorahosted.org"
+        "email": "copr-devel@lists.fedorahosted.org",
     },
     license_info={
         "name": "Apache-2.0",
         "url": "https://www.apache.org/licenses/LICENSE-2.0.html",
     },
     version=get_version(),
-    dependencies=[Depends(requires_token_when_set)], lifespan=lifespan)
+    dependencies=[Depends(requires_token_when_set)],
+    lifespan=lifespan,
+)
 
 
 @app.post("/analyze", response_model=Response)
 @track_request()
 async def analyze_log(
-    build_log: BuildLog, http_session: aiohttp.ClientSession = Depends(get_http_session)
+    build_log: BuildLog,
+    request: Request,
+    http_session: aiohttp.ClientSession = Depends(get_http_session),
 ):
     """Provide endpoint for log file submission and analysis.
     Request must be in form {"url":"<YOUR_URL_HERE>"}.
@@ -168,13 +278,19 @@ async def analyze_log(
     remote_log = RemoteLog(build_log.url, http_session)
     log_text = await remote_log.process_url()
 
-    return await perfrom_analysis(log_text)
+    return await perform_analysis(
+        log_text,
+        async_request_limiter=request.app.state.llm_request_limiter,
+        extractors=request.app.state.extractors
+    )
 
 
 @app.post("/analyze/staged", response_model=StagedResponse)
 @track_request()
 async def analyze_log_staged(
-    build_log: BuildLog, http_session: aiohttp.ClientSession = Depends(get_http_session)
+    build_log: BuildLog,
+    request: Request,
+    http_session: aiohttp.ClientSession = Depends(get_http_session),
 ):
     """Provide endpoint for log file submission and analysis.
     Request must be in form {"url":"<YOUR_URL_HERE>"}.
@@ -185,7 +301,11 @@ async def analyze_log_staged(
     remote_log = RemoteLog(build_log.url, http_session)
     log_text = await remote_log.process_url()
 
-    return await perform_staged_analysis(log_text)
+    return await perform_staged_analysis(
+        log_text,
+        async_request_limiter=request.app.state.llm_request_limiter,
+        extractors=request.app.state.extractors,
+    )
 
 
 @app.get(
@@ -245,10 +365,11 @@ async def get_koji_task_analysis(
 async def analyze_rpmbuild_koji(
     koji_instance: Annotated[str, Path(title="The Koji instance to use")],
     task_id: Annotated[int, Path(title="The task ID to analyze")],
+    request: Request,
     x_koji_token: Annotated[str, Header()] = "",
     x_koji_callback: Annotated[str, Header()] = "",
     background_tasks: BackgroundTasks = BackgroundTasks(),
-):
+):  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
     """Provide endpoint for retrieving log file analysis of a Koji task"""
 
     try:
@@ -276,16 +397,23 @@ async def analyze_rpmbuild_koji(
         # Task not yet analyzed or it timed out, so we need to start the
         # analysis in the background and return a 202 (Accepted) error.
 
+        koji_connection = request.app.state.connection_manager.koji_connections[
+            koji_instance
+        ]
         background_tasks.add_task(
             analyze_koji_task,
             task_id,
             koji_instance_config,
+            koji_connection,
+            request.app.state.llm_request_limiter,
+            request.app.state.extractors,
+            request.app.state.koji_callback_manager
         )
 
         # If a callback URL is provided, we need to add it to the callbacks
         # table so that we can notify it when the analysis is complete.
         if x_koji_callback:
-            koji_instance_config.register_callback(task_id, x_koji_callback)
+            request.app.state.koji_callback_manager.register_callback(task_id, x_koji_callback)
 
         response = BasicResponse(
             status_code=202, content=f"Beginning analysis of task {task_id}"
@@ -301,13 +429,19 @@ async def analyze_rpmbuild_koji(
     return response
 
 
-async def analyze_koji_task(task_id: int, koji_instance_config: KojiInstanceConfig):
+async def analyze_koji_task(
+    task_id: int,
+    koji_instance_config: KojiInstanceConfig,
+    koji_connection: ClientSession,
+    async_request_limiter: AsyncLimiter,
+    extractors: list[Extractor],
+    koji_callback_manager: KojiCallbackManager,
+):  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
     """Analyze a koji task and return the response"""
 
     # Get the log text from the koji task
-    koji_conn = koji_instance_config.get_connection()
     log_file_name, log_text = await get_failed_log_from_koji_task(
-        koji_conn, task_id, max_size=SERVER_CONFIG.koji.max_artifact_size
+        koji_connection, task_id, max_size=SERVER_CONFIG.koji.max_artifact_size
     )
 
     # We need to handle the metric tracking manually here, because we need
@@ -327,7 +461,11 @@ async def analyze_koji_task(task_id: int, koji_instance_config: KojiInstanceConf
         task_id=task_id,
         log_file_name=log_file_name,
     )
-    response = await perform_staged_analysis(log_text)
+    response = await perform_staged_analysis(
+        log_text,
+        async_request_limiter=async_request_limiter,
+        extractors=extractors
+    )
 
     # Now that we have the response, we can update the metrics and mark the
     # koji task analysis as completed.
@@ -335,12 +473,12 @@ async def analyze_koji_task(task_id: int, koji_instance_config: KojiInstanceConf
     await KojiTaskAnalysis.add_response(task_id, metrics_id)
 
     # Notify any callbacks that the analysis is complete.
-    for callback in koji_instance_config.get_callbacks(task_id):
+    for callback in koji_callback_manager.get_callbacks(task_id):
         LOG.info("Notifying callback %s of task %d completion", callback, task_id)
         asyncio.create_task(send_koji_callback(callback, task_id))
 
     # Now that it's sent, we can clear the callbacks for this task.
-    koji_instance_config.clear_callbacks(task_id)
+    koji_callback_manager.clear_callbacks(task_id)
 
     return response
 
@@ -353,18 +491,18 @@ async def send_koji_callback(callback: str, task_id: int):
 
 
 @app.get("/queue/print")
-async def queue_print(msg: str):
+async def queue_print(msg: str, request: Request):
     """Debug endpoint to test the LLM request queue"""
     LOG.info("Will print %s", msg)
 
-    result = await async_log(msg)
+    result = await async_log(msg, request)
 
     LOG.info("Printed %s and returned it", result)
 
 
-async def async_log(msg):
+async def async_log(msg: str, request: Request):
     """Debug function to test the LLM request queue"""
-    async with SERVER_CONFIG.inference.get_limiter():
+    async with request.app.state.llm_request_limiter:
         LOG.critical(msg)
     return msg
 
@@ -378,7 +516,9 @@ async def get_version_wrapper():
 @app.post("/analyze/stream", response_class=StreamingResponse)
 @track_request()
 async def analyze_log_stream(
-    build_log: BuildLog, http_session: aiohttp.ClientSession = Depends(get_http_session)
+    build_log: BuildLog,
+    request: Request,
+    http_session: aiohttp.ClientSession = Depends(get_http_session),
 ):
     """Stream response endpoint for Logdetective.
     Request must be in form {"url":"<YOUR_URL_HERE>"}.
@@ -389,7 +529,11 @@ async def analyze_log_stream(
     remote_log = RemoteLog(build_log.url, http_session)
     log_text = await remote_log.process_url()
     try:
-        stream = perform_analyis_stream(log_text)
+        stream = perform_analysis_stream(
+            log_text,
+            async_request_limiter=request.app.state.llm_request_limiter,
+            extractors=request.app.state.extractors,
+        )
     except aiohttp.ClientResponseError as ex:
         raise HTTPException(
             status_code=400,
@@ -421,6 +565,7 @@ def is_valid_webhook_secret(forge, x_gitlab_token):
 async def receive_gitlab_job_event_webhook(
     job_hook: JobHook,
     background_tasks: BackgroundTasks,
+    request: Request,
     x_gitlab_instance: Annotated[str | None, Header()],
     x_gitlab_token: Annotated[str | None, Header()] = None,
 ):
@@ -441,11 +586,21 @@ async def receive_gitlab_job_event_webhook(
 
     # Handle the message in the background so we can return 204 immediately
     gitlab_cfg = SERVER_CONFIG.gitlab.instances[forge.value]
+    gitlab_connection = request.app.state.connection_manager.gitlab_connections[
+        forge.value
+    ]
+    gitlab_http_session = request.app.state.connection_manager.gitlab_http_sessions[
+        forge.value
+    ]
     background_tasks.add_task(
         process_gitlab_job_event,
         gitlab_cfg,
+        gitlab_connection,
+        gitlab_http_session,
         forge,
         job_hook,
+        request.app.state.llm_request_limiter,
+        request.app.state.extractors
     )
 
     # No return value or body is required for a webhook.
@@ -467,6 +622,7 @@ async def receive_gitlab_emoji_event_webhook(
     x_gitlab_token: Annotated[str | None, Header()],
     emoji_hook: EmojiHook,
     background_tasks: BackgroundTasks,
+    request: Request,
 ):
     """Webhook endpoint for receiving emoji event notifications from Gitlab
     https://docs.gitlab.com/user/project/integrations/webhook_events/#emoji-events
@@ -519,10 +675,14 @@ async def receive_gitlab_emoji_event_webhook(
     # Inform the lookup table that we are processing this emoji
     emoji_lookup[key] = False
 
+    gitlab_connection = request.app.state.connection_manager.gitlab_connections[
+        x_gitlab_instance
+    ]
     # Create a background task to process the emojis on this Merge Request.
     background_tasks.add_task(
         schedule_emoji_collection_for_mr,
         forge,
+        gitlab_connection,
         emoji_hook.merge_request.target_project_id,
         emoji_hook.merge_request.iid,
         background_tasks,
@@ -534,17 +694,21 @@ async def receive_gitlab_emoji_event_webhook(
 
 
 async def schedule_emoji_collection_for_mr(
-    forge: Forge, project_id: int, mr_iid: int, background_tasks: BackgroundTasks
+    forge: Forge,
+    gitlab_connection: Gitlab,
+    project_id: int,
+    mr_iid: int,
+    background_tasks: BackgroundTasks,
 ):
     """Background task to update the database on emoji reactions"""
 
     key = (forge, project_id, mr_iid)
 
     # FIXME: Look up the connection from the Forge  # pylint: disable=fixme
-    gitlab_conn = SERVER_CONFIG.gitlab.instances[forge.value].get_connection()
+    # gitlab_conn = SERVER_CONFIG.gitlab.instances[forge.value].get_connection()
 
     LOG.debug("Looking up emojis for %s, %d, %d", forge, project_id, mr_iid)
-    await collect_emojis_for_mr(project_id, mr_iid, gitlab_conn)
+    await collect_emojis_for_mr(project_id, mr_iid, gitlab_connection)
 
     # Check whether we've been asked to re-schedule this lookup because
     # another request came in while it was processing.
@@ -555,6 +719,7 @@ async def schedule_emoji_collection_for_mr(
         background_tasks.add_task(
             schedule_emoji_collection_for_mr,
             forge,
+            gitlab_connection,
             project_id,
             mr_iid,
             background_tasks,
@@ -677,25 +842,27 @@ async def get_metrics(
     return await handler()
 
 
-async def collect_emoji_task():
+async def collect_emoji_task(connection_manager: ConnectionManager):
     """Collect emoji feedback.
     Query only comments created in the last year.
     """
 
-    for instance in SERVER_CONFIG.gitlab.instances.values():
+    for instance_url, instance in SERVER_CONFIG.gitlab.instances.items():
         LOG.info(
             "Collect emoji feedback for %s started at %s",
             instance.url,
             datetime.datetime.now(datetime.timezone.utc),
         )
-        await collect_emojis(instance.get_connection(), TimePeriod(weeks=54))
+        await collect_emojis(
+            connection_manager.gitlab_connections[instance_url], TimePeriod(weeks=54)
+        )
         LOG.info(
             "Collect emoji feedback finished at %s",
             datetime.datetime.now(datetime.timezone.utc),
         )
 
 
-async def schedule_collect_emojis_task():
+async def schedule_collect_emojis_task(connection_manager: ConnectionManager):
     """Schedule the collect_emojis_task to run on a configured interval"""
     while True:
         seconds_until_run = SERVER_CONFIG.general.collect_emojis_interval
@@ -703,6 +870,6 @@ async def schedule_collect_emojis_task():
         await asyncio.sleep(seconds_until_run)
 
         try:
-            await collect_emoji_task()
+            await collect_emoji_task(connection_manager=connection_manager)
         except Exception as e:  # pylint: disable=broad-exception-caught
             LOG.exception("Error in collect_emoji_task: %s", e)

{logdetective-2.10.0.dist-info → logdetective-2.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logdetective
-Version: 2.10.0
+Version: 2.12.0
 Summary: Log using LLM AI to search for build/test failures and provide ideas for fixing these.
 License: Apache-2.0
 License-File: LICENSE
@@ -33,7 +33,7 @@ Requires-Dist: backoff (==2.2.1) ; extra == "server" or extra == "server-testing
 Requires-Dist: drain3 (>=0.9.11,<0.10.0)
 Requires-Dist: fastapi (>=0.111.1,<1.0.0) ; extra == "server" or extra == "server-testing"
 Requires-Dist: flexmock (>=0.12.2,<0.13.0) ; extra == "testing"
-Requires-Dist: huggingface-hub (>0.23.2,<0.35.0)
+Requires-Dist: huggingface-hub (>=0.23.0,<1.4.0)
 Requires-Dist: koji (>=1.35.0,<2.0.0) ; extra == "server" or extra == "server-testing"
 Requires-Dist: llama-cpp-python (>0.2.56,!=0.2.86,<1.0.0)
 Requires-Dist: matplotlib (>=3.8.4,<4.0.0) ; extra == "server" or extra == "server-testing"

{logdetective-2.10.0.dist-info → logdetective-2.12.0.dist-info}/RECORD

@@ -10,7 +10,7 @@ logdetective/prompts.yml,sha256=i3z6Jcb4ScVi7LsxOpDlKiXrcvql3qO_JnLzkAKMn1c,3870
 logdetective/remote_log.py,sha256=28QvdQiy7RBnd86EKCq_A75P21gSNlCbgxJe5XAe9MA,2258
 logdetective/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 logdetective/server/compressors.py,sha256=y4aFYJ_9CbYdKuAI39Kc9GQSdPN8cSJ2c_VAz3T47EE,5249
-logdetective/server/config.py,sha256=cKUmNCJyNyEid0bPTiUjr8CQuBYBab5bC79Axk2h0z8,2525
+logdetective/server/config.py,sha256=dYoqvexnMo8LBXhXezMIEqUwzTsRD-eWvRIFIYNv388,2540
 logdetective/server/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 logdetective/server/database/base.py,sha256=HSV2tgye7iYTDzJD1Q5X7_nlLuTMIFP-hRVQMYxngHQ,2073
 logdetective/server/database/models/__init__.py,sha256=zoZMCt1_7tewDa6eEIIX_xrdN-tLegSiPNg5NiYaV3o,850
@@ -18,23 +18,23 @@ logdetective/server/database/models/exceptions.py,sha256=4ED7FSSA1liV9-7VIN2BwUi
 logdetective/server/database/models/koji.py,sha256=HNWxHYDxf4JN9K2ue8-V8dH-0XY5ZmxqH7Y9lAIbILA,6436
 logdetective/server/database/models/merge_request_jobs.py,sha256=MxiAVKQIsQMbFylBsmYBmVXYvid-4_5mwwXLfWdp6_w,19965
 logdetective/server/database/models/metrics.py,sha256=4xsUdbtlp5PI1-iJQc5Dd8EPDgVVplD9hJRWeRDn43k,15443
-logdetective/server/emoji.py,sha256=nt3i_D5bk67RF4SlIetlLhLcgcxz9TEniC2iRYJx81w,5066
+logdetective/server/emoji.py,sha256=zSaYtLpSkpRCXpjMWnHR1bYwkmobMJASZ7YNalrd85U,5274
 logdetective/server/exceptions.py,sha256=WN715KLL3ya6FiZ95v70VSbNuVhGuHFzxm2OeEPWQCw,981
-logdetective/server/gitlab.py,sha256=putpnf8PfGsCZJsqWZA1rMovRGnyagoQmgpKLqtA-aQ,16743
+logdetective/server/gitlab.py,sha256=X9JSotUUlG9bOWYbUNKt9KqLUAj6Uocd2KNpfn35ccU,17192
 logdetective/server/koji.py,sha256=LG1pRiKUFvYFRKzgQoUG3pUHfcEwMoaMNjUSMKw_pBA,5640
-logdetective/server/llm.py,sha256=bmA6LsV80OdO60q4WLoKuehuVDEYq-HhBAYcZeLfrv8,10150
+logdetective/server/llm.py,sha256=wHMxRbAjI0q3osR5mRDR1kqww_6Pkc7JpF1mh9e6Mg8,10855
 logdetective/server/metric.py,sha256=wLOpgcAch3rwhPA5P2YWUeMNAPsvRGseRjH5HlTb7JM,4529
-logdetective/server/models.py,sha256=AJyycAEEl2o6TH4eAqVMlt5woqAB5M8ze2L575leA_I,19835
+logdetective/server/models.py,sha256=iJ-5UgScKKSRL8fRCsM23Z34P3p98LaduwWO-q9rudo,13041
 logdetective/server/plot.py,sha256=8LERgY3vQckaHZV2PZfOrZT8CjCAiji57QCmRW24Rfo,14697
-logdetective/server/server.py,sha256=JueU-5c8t9h1CZy4gtoEeT8VSEirpeS0K3wrfqTPvAc,25381
+logdetective/server/server.py,sha256=AM10P72tc_7N0GhH_N7msFhLr7ZGNgIfgTxt2sjasVE,30982
 logdetective/server/templates/base_response.html.j2,sha256=BJGGV_Xb0Lnue8kq32oG9lI5CQDf9vce7HMYsP-Pvb4,2040
 logdetective/server/templates/gitlab_full_comment.md.j2,sha256=4UujUzl3lmdbNEADsxn3HVrjfUiUu2FvUlp9MDFGXQI,2321
 logdetective/server/templates/gitlab_short_comment.md.j2,sha256=2krnMlGqqju2V_6pE0UqUR1P674OFaeX5BMyY5htTOQ,2022
 logdetective/server/utils.py,sha256=0BZ8WmzXNEtkUty1kOyFbBxDZWL0Icc8BUrxuHw9uvs,4015
 logdetective/skip_snippets.yml,sha256=reGlhPPCo06nNUJWiC2LY-OJOoPdcyOB7QBTSMeh0eg,487
 logdetective/utils.py,sha256=yalhySOF_Gzmqx_Ft9qad3TplAfZ6LOmauGXEJfKWiE,9803
-logdetective-2.10.0.dist-info/METADATA,sha256=ii3l-h7Tpnc9BByVL1BYDj8XkbzKuqD1YW-A4gbm66E,23273
-logdetective-2.10.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-logdetective-2.10.0.dist-info/entry_points.txt,sha256=3K_vXja6PmcA8sNdUi63WdImeiNhVZcEGPTaoJmltfA,63
-logdetective-2.10.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-logdetective-2.10.0.dist-info/RECORD,,
+logdetective-2.12.0.dist-info/METADATA,sha256=q8qwE4AyHr0WfJZwNMbCb3-X0mBQfreXhuNtYxSfOSM,23273
+logdetective-2.12.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+logdetective-2.12.0.dist-info/entry_points.txt,sha256=3K_vXja6PmcA8sNdUi63WdImeiNhVZcEGPTaoJmltfA,63
+logdetective-2.12.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+logdetective-2.12.0.dist-info/RECORD,,