lightman_ai 0.20.1__py3-none-any.whl

lightman_ai/integrations/service_desk/integration.py

@@ -0,0 +1,89 @@
+import logging
+import os
+from typing import Any, Self
+
+import httpx
+import stamina
+from lightman_ai.integrations.service_desk.constants import (
+    SERVICE_DESK_RETRY_ATTEMPTS,
+    SERVICE_DESK_RETRY_ON,
+    SERVICE_DESK_RETRY_TIMEOUT,
+)
+from lightman_ai.integrations.service_desk.exceptions import (
+    MissingIssueIDError,
+    handle_service_desk_exceptions,
+)
+
+logger = logging.getLogger("lightman")
+
+
+class ServiceDeskIntegration:
+    """
+    Service Desk integration using httpx to create tickets.
+
+    Provides a simple interface to create Service Desk issues with proper
+    authentication and error handling.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        username: str,
+        api_token: str,
+        verify_ssl: bool = True,
+        timeout: float = 30.0,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.username = username
+        self.api_token = api_token
+        self.client = httpx.AsyncClient(
+            base_url=self.base_url,
+            auth=(username, api_token),
+            headers={
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+            },
+            verify=verify_ssl,
+            timeout=timeout,
+        )
+
+    @classmethod
+    def from_env(cls) -> Self:
+        required_vars = ["SERVICE_DESK_URL", "SERVICE_DESK_USER", "SERVICE_DESK_TOKEN"]
+        missing = [var for var in required_vars if not os.environ.get(var)]
+        if missing:
+            raise ValueError(f"Missing required environment variable(s): {', '.join(missing)}")
+        return cls(
+            base_url=os.environ["SERVICE_DESK_URL"],
+            username=os.environ["SERVICE_DESK_USER"],
+            api_token=os.environ["SERVICE_DESK_TOKEN"],
+        )
+
+    async def create_request_of_type(
+        self,
+        *,
+        project_key: str,
+        summary: str,
+        description: str,
+        request_id_type: str,
+    ) -> str:
+        payload: dict[str, Any] = {
+            "serviceDeskId": project_key,
+            "requestTypeId": request_id_type,
+            "requestFieldValues": {"summary": summary, "description": description},
+        }
+        for attempt in stamina.retry_context(
+            on=SERVICE_DESK_RETRY_ON,
+            attempts=SERVICE_DESK_RETRY_ATTEMPTS,
+            timeout=SERVICE_DESK_RETRY_TIMEOUT,
+        ):
+            with attempt:
+                async with handle_service_desk_exceptions():
+                    response = await self.client.post("/rest/servicedeskapi/request", json=payload)
+                    response.raise_for_status()
+                    data = response.json()
+                    issue_id = data.get("issueId")
+                    if not issue_id:
+                        raise MissingIssueIDError()
+                    logger.info("Successfully created Service Desk issue: %s", issue_id)
+        return str(issue_id)

lightman_ai/main.py

@@ -0,0 +1,95 @@
+import asyncio
+import logging
+
+from lightman_ai.ai.base.agent import BaseAgent
+from lightman_ai.ai.utils import get_agent_class_from_agent_name
+from lightman_ai.article.models import ArticlesList, SelectedArticle, SelectedArticlesList
+from lightman_ai.integrations.service_desk.integration import (
+    ServiceDeskIntegration,
+)
+from lightman_ai.sources.the_hacker_news import TheHackerNewsSource
+
+logger = logging.getLogger("lightman")
+
+
+def _get_articles() -> ArticlesList:
+    return TheHackerNewsSource().get_articles()
+
+
+def _classify_articles(articles: ArticlesList, agent: BaseAgent) -> SelectedArticlesList:
+    return agent.get_prompt_result(prompt=str(articles))
+
+
+def _create_service_desk_issues(
+    selected_articles: list[SelectedArticle],
+    service_desk_client: ServiceDeskIntegration,
+    project_key: str,
+    request_id_type: str,
+) -> None:
+    async def schedule_task(article: SelectedArticle) -> None:
+        try:
+            description = f"*Why is relevant:*\n{article.why_is_relevant}\n\n*Source:* {article.link}\n\n*Score:* {article.relevance_score}/10"
+            await service_desk_client.create_request_of_type(
+                project_key=project_key,
+                summary=article.title,
+                description=description,
+                request_id_type=request_id_type,
+            )
+            logger.info("Created issue for article %s", article.link)
+        except Exception:
+            logger.exception("Could not create ServiceDesk issue: %s, %s", article.title, article.link)
+            raise
+
+    async def create_all() -> None:
+        tasks = []
+        for article in selected_articles:
+            tasks.append(schedule_task(article))
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        errors = [result for result in results if isinstance(result, Exception)]
+        if errors:
+            raise ExceptionGroup("Could not create all ServiceDesk issues", errors)
+
+    asyncio.run(create_all())
+
+
+def lightman(
+    agent: str,
+    prompt: str,
+    score_threshold: int,
+    project_key: str | None = None,
+    request_id_type: str | None = None,
+    dry_run: bool = False,
+    model: str | None = None,
+) -> list[SelectedArticle]:
+    articles: ArticlesList = _get_articles()
+
+    agent_class = get_agent_class_from_agent_name(agent)
+    agent_instance = agent_class(prompt, model, logger=logger)
+    logger.info("Selected %s.", agent_instance)
+
+    classified_articles = _classify_articles(
+        articles=articles,
+        agent=agent_instance,
+    )
+
+    selected_articles: list[SelectedArticle] = classified_articles.get_articles_with_score_gte_threshold(
+        score_threshold
+    )
+    if selected_articles:
+        logger.info("Found these articles: %s", selected_articles)
+    else:
+        logger.info("No articles found to be relevant. Total returned articles by AI %s", len(classified_articles))
+
+    if not dry_run:
+        if not project_key or not request_id_type:
+            raise ValueError("Missing Service Desk's project key or request id type")
+
+        service_desk_client = ServiceDeskIntegration.from_env()
+        _create_service_desk_issues(
+            selected_articles=selected_articles,
+            service_desk_client=service_desk_client,
+            project_key=project_key,
+            request_id_type=request_id_type,
+        )
+
+    return selected_articles

lightman_ai/sources/base.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+
+from lightman_ai.article.models import ArticlesList
+
+
+class BaseSource(ABC):
+    @abstractmethod
+    def get_articles(self) -> ArticlesList: ...

lightman_ai/sources/the_hacker_news.py

@@ -0,0 +1,57 @@
+from typing import override
+from xml.etree import ElementTree
+
+import httpx
+import stamina
+from httpx import Client
+from lightman_ai.article.models import Article, ArticlesList
+from lightman_ai.sources.base import BaseSource
+
+_RETRY_ON = httpx.TransportError
+_ATTEMPTS = 5
+_TIMEOUT = 5
+
+
+THN_URL = "https://feeds.feedburner.com/TheHackersNews"
+
+
+class TheHackerNewsSource(BaseSource):
+    @override
+    def get_articles(self) -> ArticlesList:
+        """Return the articles that are present in THN feed."""
+        feed = self.get_feed()
+        articles = self._xml_to_list_of_articles(feed)
+        return ArticlesList(articles=articles)
+
+    def get_feed(self) -> str:
+        """Retrieve the TheHackerNews' RSS Feed."""
+        for attempt in stamina.retry_context(
+            on=_RETRY_ON,
+            attempts=_ATTEMPTS,
+            timeout=_TIMEOUT,
+        ):
+            with Client() as http_client, attempt:
+                hacker_news_feed = http_client.get(THN_URL)
+                hacker_news_feed.raise_for_status()
+        return hacker_news_feed.text
+
+    def _xml_to_list_of_articles(self, xml: str) -> list[Article]:
+        root = ElementTree.fromstring(xml)
+        channel = root.find("channel")
+        assert channel
+        items = channel.findall("item")
+
+        parsed = []
+
+        for item in items:
+            title = item.findtext("title", default="").strip()
+            description = self._clean(item.findtext("description", default="").strip())
+            link = item.findtext("link", default="").strip()
+
+            parsed.append(Article(title=title, description=description, link=link))
+        return parsed
+
+    @staticmethod
+    def _clean(text: str) -> str:
+        """Remove non-useful characters."""
+        return text.replace("\\n", "").replace("       ", "")

lightman_ai-0.20.1.dist-info/METADATA

@@ -0,0 +1,394 @@
+Metadata-Version: 2.4
+Name: lightman_ai
+Version: 0.20.1
+Summary: Cybersecurity news aggregator.
+Author-email: sdn4z <imsdn4z@gmail.com>
+License-File: LICENSE
+Requires-Python: <4,>=3.13
+Requires-Dist: click<9.0.0,>=8.1.7
+Requires-Dist: httpx<1.0.0,>=0.28.0
+Requires-Dist: logfire>=3.25.0
+Requires-Dist: pydantic-ai-slim[google,openai]>=0.4.4
+Requires-Dist: pydantic-settings[dotenv]<3.0.0,>=2.9.1
+Requires-Dist: python-dotenv<2.0.0,>=1.1.1
+Requires-Dist: sentry-sdk<3.0.0,>=2.21.0
+Requires-Dist: stamina<26.0.0,>=25.1.0
+Requires-Dist: tiktoken<1.0.0,>=0.9.0
+Requires-Dist: tomlkit<1.0.0,>=0.13.3
+Provides-Extra: lint
+Requires-Dist: mypy<2.0.0,>=1.1.1; extra == 'lint'
+Requires-Dist: ruff<1.0.0,>=0.11.0; extra == 'lint'
+Provides-Extra: local
+Requires-Dist: codespell<3.0.0,>=2.2.4; extra == 'local'
+Requires-Dist: commitizen<5.0.0,>=4.8.3; extra == 'local'
+Requires-Dist: ipdb<1.0.0,>=0.13.13; extra == 'local'
+Requires-Dist: pdbpp<1.0.0,>=0.11.6; extra == 'local'
+Requires-Dist: pre-commit<4.0.0,>=3.2.2; extra == 'local'
+Provides-Extra: test
+Requires-Dist: pytest-asyncio<1.0.0,>=0.26.0; extra == 'test'
+Requires-Dist: pytest-cov<6.0.0,>=5.0.0; extra == 'test'
+Requires-Dist: pytest<9.0.0,>=8.0.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# 🔍 Lightman AI
+
+> **AI-Powered Cybersecurity News Intelligence Platform*
+
+---
+
+Lightman AI is an intelligent cybersecurity news aggregation and risk assessment platform that helps organizations stay ahead of potential security threats. By leveraging advanced AI agents, it automatically monitors cybersecurity news sources, analyzes content for relevance, and integrates with service desk systems for streamlined threat intelligence workflows.
+
+## ✨ Key Features
+
+- 🤖 **AI-Powered Classification**: Uses OpenAI GPT and Google Gemini models to intelligently classify cybersecurity news
+- 📰 **Automated News Aggregation**: Monitors multiple cybersecurity news sources (TheHackerNews for now)
+- 🎯 **Risk Scoring**: Configurable relevance scoring to filter noise and focus on critical threats
+- 🔗 **Service Desk Integration**: Automatically creates tickets for identified security risks
+- 📊 **Evaluation Framework**: Built-in tools to test and optimize AI agent performance
+- ⚙️ **Flexible Configuration**: TOML-based configuration with multiple prompt templates
+- 🚀 **CLI Interface**: Simple command-line interface for automation and scripting
+
+
+## 📖 Table of Contents
+
+- [Quick Start](#-quick-start)
+- [Installation](#-installation)
+- [Configuration](#-configuration)
+- [Usage](#-usage)
+- [AI Agents & Models](#-ai-agents--models)
+- [Evaluation & Testing](#-evaluation--testing)
+- [Development](#-development)
+- [Contributing](#-contributing)
+- [License](#license)
+
+## 🚀 Quick Start
+
+### pip
+
+1. **Install Lightman AI**:
+   ```bash
+   pip install lightman_ai
+   ```
+
+2. **Configure your AI agent** (OpenAI or Gemini):
+   ```bash
+   export OPENAI_API_KEY="your-api-key"
+   # or
+   export GOOGLE_API_KEY="your-api-key"
+   ```
+
+   or store you API KEYs in a .env file
+   ```bash
+   OPENAI_API_KEY="your-api-key"
+   # or
+   GOOGLE_API_KEY="your-api-key"
+   ```
+
+3. **Run the scanner**:
+   ```bash
+   lightman run --agent openai --score 7
+   ```
+   or let it pick up the default values from your `lightman.toml` file
+   ```bash
+   lightman run
+   ```
+
+### Docker
+
+1. **Create configuration file**:
+   ```bash
+   echo '[default]
+   agent = "openai"
+   score_threshold = 8
+   prompt = "development"
+   
+   [prompts]
+   development = "Analyze cybersecurity news for relevance to our organization."' > lightman.toml
+   ```
+
+2. **Run with Docker**:
+   ```bash
+   docker run --rm \
+     -v $(pwd)/lightman.toml:/app/lightman.toml \
+     -e OPENAI_API_KEY="your-api-key" \
+     elementsinteractive/lightman-ai:latest \
+     lightman run --config-file /app/lightman.toml --score 7
+   ```
+
+4. **View results**: Lightman will analyze cybersecurity news and output relevant articles that meet your score threshold.
+
+## 📥 Installation
+
+### Docker
+Lightman AI has an available Docker image on Docker Hub:
+
+```bash
+# Pull the latest image
+docker pull elementsinteractive/lightman-ai:latest
+
+# Create your configuration file
+
+   echo '[default]
+   agent = "openai"
+   score_threshold = 8
+   prompt = "development"
+   
+   [prompts]
+   development = "Analyze cybersecurity news for relevance to our organization."' > lightman.toml
+   ```
+
+
+# Run with mounted configuration
+```bash
+docker run -d \
+  --name lightman-ai \
+  -v $(pwd)/lightman.toml:/app/lightman.toml \
+  -e OPENAI_API_KEY="your-api-key" \
+  elementsinteractive/lightman-ai:latest \
+  lightman run --config-file /app/lightman.toml
+```
+
+**Docker Environment Variables:**
+- `OPENAI_API_KEY` - Your OpenAI API key
+- `GOOGLE_API_KEY` - Your Google Gemini API key
+- `SERVICE_DESK_URL` - Service desk instance URL (optional)
+- `SERVICE_DESK_USER` - Service desk username (optional)
+- `SERVICE_DESK_TOKEN` - Service desk API token (optional)
+
+
+
+### Development Installation
+```bash
+git clone git@github.com:elementsinteractive/lightman-ai.git
+cd lightman_ai
+just venv  # Creates virtual environment and installs dependencies
+```
+
+## ⚙️ Configuration
+
+Lightman AI uses TOML configuration files for flexible setup. Create a `lightman.toml` file:
+
+```toml
+[default]
+agent = 'openai'              # AI agent to use (openai, gemini)
+score_threshold = 8           # Minimum relevance score (1-10)
+prompt = 'development'        # Prompt template to use
+
+# Optional: Service desk integration
+service_desk_project_key = "SEC"
+service_desk_request_id_type = "incident"
+
+[prompts]
+development = """
+Analyze the following cybersecurity news articles and determine their relevance to our organization.
+Rate each article from 1-10 based on potential impact and urgency.
+Focus on: data breaches, malware, vulnerabilities, and threat intelligence.
+"""
+
+custom_prompt = """
+Your custom analysis prompt here...
+"""
+```
+
+It also supports having separate files for your prompts and your configuration settings. Specify the path with `--prompt`.
+
+`lightman.toml`
+```toml
+[default]
+agent = 'openai'              # AI agent to use (openai, gemini)
+score_threshold = 8           # Minimum relevance score (1-10)
+prompt = 'development'        # Prompt template to use
+
+# Optional: Service desk integration
+service_desk_project_key = "SEC"
+service_desk_request_id_type = "incident"
+```
+
+`prompts.toml`
+```toml
+[prompts]
+development = """
+Analyze the following cybersecurity news articles and determine their relevance to our organization.
+Rate each article from 1-10 based on potential impact and urgency.
+Focus on: data breaches, malware, vulnerabilities, and threat intelligence.
+"""
+
+custom_prompt = """
+Your custom analysis prompt here...
+"""
+```
+### Environment Variables
+
+Set up your AI provider credentials:
+
+```bash
+# For OpenAI
+export OPENAI_API_KEY="your-openai-api-key"
+
+# For Google Gemini
+export GOOGLE_API_KEY="your-google-api-key"
+
+# Optional: Service desk integration
+export SERVICE_DESK_URL="https://your-company.atlassian.net"
+export SERVICE_DESK_USER="your-username"
+export SERVICE_DESK_TOKEN="your-api-token"
+
+```
+You can also specify a different path for your .env file with the `--env-file` option
+
+
+## 🔧 Usage
+
+### Basic Usage
+
+```bash
+# Run with default settings
+lightman run
+
+# Use specific AI agent and score threshold
+lightman run --agent gemini --score 7
+
+# Use custom prompt template
+lightman run --prompt custom_prompt --config-file ./my-config.toml
+
+# Use custom environment file
+lightman run --env-file production.env --agent openai --score 8
+
+# Dry run (preview results without creating service desk tickets)
+lightman run --dry-run --agent openai --score 9
+```
+
+### Command Line Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `--agent` | AI agent to use (`openai`, `gemini`) | From config file |
+| `--score` | Minimum relevance score (1-10) | From config file |
+| `--prompt` | Prompt template name | From config file |
+| `--config-file` | Path to configuration file | `lightman.toml` |
+| `--config` | Configuration section to use | `default` |
+| `--env-file` | Path to environment variables file | `.env` |
+| `--dry-run` | Preview results without taking action | `false` |
+| `--prompt-file` | File containing prompt templates | `lightman.toml` |
+
+### Example Workflows
+
+**Daily Security Monitoring**:
+```bash
+# Local installation
+lightman run --agent openai --score 8 --prompt security_critical
+
+# With custom environment file
+lightman run --env-file production.env --agent openai --score 8
+
+# Docker 
+docker run --rm \
+  -v $(pwd)/lightman.toml:/app/lightman.toml \
+  -e OPENAI_API_KEY="$OPENAI_API_KEY" \
+  elementsinteractive/lightman-ai:latest \
+  lightman run --config-file /app/lightman.toml --score 8
+```
+
+
+**Weekly Risk Assessment**:
+```bash
+# Local installation
+lightman run --agent gemini --score 6 --prompt weekly_assessment
+
+# With environment-specific settings
+lightman run --env-file weekly.env --agent gemini --score 6
+
+# Docker 
+docker run --rm \
+  -v $(pwd)/lightman.toml:/app/lightman.toml \
+  -e GOOGLE_API_KEY="$GOOGLE_API_KEY" \
+  elementsinteractive/lightman-ai:latest \
+  lightman run --config-file /app/lightman.toml --agent gemini --score 6
+```
+
+**Integration Testing**:
+```bash
+# Test configuration without creating tickets
+lightman run --dry-run --config testing
+
+# Test with staging environment
+lightman run --env-file staging.env --dry-run --config testing
+```
+
+
+
+## 📊 Evaluation & Testing
+
+Lightman AI includes a comprehensive evaluation framework to test and optimize AI agent performance:
+
+### Running Evaluations
+
+```bash
+# Evaluate agent performance
+just eval --agent openai --samples 3 --score 7
+
+# Compare different agents
+just eval --agent gemini --samples 5 
+
+# Add tags to differentiate runs from one another
+just eval --agent gemini --samples 5 --tag "first-run"
+just eval --agent gemini --samples 5 --tag "second-run"
+
+# Test custom prompts
+just eval --prompt custom_security --samples 10
+
+# Use custom environment file for evaluation
+python -m eval.cli --env-file production.env --agent openai --samples 3
+```
+
+You can also provide defaults in a `toml` file for `eval`.
+
+```toml
+[eval]
+agent = 'openai'
+score_threshold = 8
+prompt = 'classify'
+samples = 3
+```
+
+### Evaluation Metrics
+
+The evaluation system measures:
+- **Precision**: Accuracy of threat identification
+- **Recall**: Coverage of actual security threats
+- **F1 Score**: Balanced performance metric
+- **Score Distribution**: Analysis of relevance scoring patterns
+
+### Evaluation Dataset
+
+For precision evaluation, Lightman AI uses a curated set of **unclassified cybersecurity articles** that serve as ground truth data. These articles include:
+
+- **Real-world news articles** from various cybersecurity sources
+- **Mixed relevance levels** - both highly relevant and irrelevant security news
+- **Diverse threat categories** - malware, data breaches, vulnerabilities, policy changes
+- **Pre-validated classifications** by security experts for accuracy benchmarking
+
+The evaluation framework compares the AI agent's classifications against these known classifications to measure:
+- How accurately the agent identifies truly relevant threats (precision)
+- How well it avoids false positives from irrelevant news
+- Consistency across different types of security content
+
+This approach ensures that performance metrics reflect real-world usage scenarios where the AI must distinguish between various types of cybersecurity news content.
+
+**Make sure to fill in the `RELEVANT_ARTICLES` with the ones you classify as relevant, so that you can compare the accuracy after running the `eval` script.*** 
+
+## Sentry 
+
+- The application will automatically pick up and use environment variables if they are present in your environment or `.env` file.
+- To enable Sentry error monitoring, set the `SENTRY_DSN` environment variable. This is **mandatory** for Sentry to be enabled. If `SENTRY_DSN` is not set, Sentry will be skipped and the application will run normally.
+- If Sentry fails to initialize for any reason (e.g., network issues, invalid DSN), the application will log a warning and continue execution without error monitoring.
+- Sentry is **optional**: the application does not require it to function, and all features will work even if Sentry is not configured or fails to start.
+
+## 📄 License
+
+This project is licensed under the [MIT License](LICENSE) - see the LICENSE file for details.
+
+## 🙏 Acknowledgments
+
+- **TheHackerNews** for providing cybersecurity news data
+

lightman_ai-0.20.1.dist-info/RECORD

@@ -0,0 +1,34 @@
+lightman_ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lightman_ai/cli.py,sha256=Y3vl4xsJTBUBHRAR4zlMhjK5Cr2HNWRokWaGGuxFCQU,3775
+lightman_ai/constants.py,sha256=qfZgcTLK51l--JDhns-uRANjccFEPN6iTFsJKn8T4vs,101
+lightman_ai/main.py,sha256=Av4Jr8MhwVLUrVeCg24SCnpaT49hPYFlQJD0ABGfJGc,3379
+lightman_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lightman_ai/ai/utils.py,sha256=vFTN8Tto7QHMV4DpTzn8Dz06niHm_bbgPivyc-rD1aE,509
+lightman_ai/ai/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lightman_ai/ai/base/agent.py,sha256=fFjF_nCzoba4hbSfRPmIm9dxW6A45qJWTrSbrq9NFto,985
+lightman_ai/ai/base/exceptions.py,sha256=OLM0Fif66rAZe9I4xHIDHCDN61mObaCMH7KKlfSmw6Y,107
+lightman_ai/ai/gemini/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lightman_ai/ai/gemini/agent.py,sha256=1pDdKrm2wCxTFxlHQHXWENiys1FWar6kxppGYFC3YgI,641
+lightman_ai/ai/gemini/exceptions.py,sha256=EJm9qSwI9JhrqPssGQP-cO8vOI--u0V1a6X4tQdWW3A,407
+lightman_ai/ai/openai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lightman_ai/ai/openai/agent.py,sha256=bMZS-F58WaXDR6f3j5DhtZ4077Gy80_oGYJczB7nV74,1043
+lightman_ai/ai/openai/exceptions.py,sha256=V41fLkhkDguKU9_Wy0vMn0UXHmuAkqqXTmrcNKTNRZE,2414
+lightman_ai/article/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lightman_ai/article/models.py,sha256=Zyx4CKBNGDcK9IWnPOb6CK6nKH2s40UaqsoZlIjSidU,1598
+lightman_ai/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lightman_ai/core/config.py,sha256=ppWNoNivNqxGi4TOZIMaTGo46W7Ic1a8cO8hWVAkkps,3031
+lightman_ai/core/exceptions.py,sha256=XKxA-EmLvd9cmbkUfdrBd27gsEFyIkSCQBf4pD-1AJk,239
+lightman_ai/core/sentry.py,sha256=yJYqZWhLH1OR11gVr1YPF0gPUSLjm8klnSmXFdDpyEo,1039
+lightman_ai/core/settings.py,sha256=pVhA0naxk7NRnJXRQB-CHVeIvYCEC2jP4mv8cbdfJYY,296
+lightman_ai/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lightman_ai/integrations/service_desk/__init__.py,sha256=Ijs7_ysJVwiT_Y1U8iPOV17E7dtkVzNXL00d8cgyaCc,66
+lightman_ai/integrations/service_desk/constants.py,sha256=ropNDMengLp96pXD6wq2voWPeBESt6f2Wnfk7845mck,306
+lightman_ai/integrations/service_desk/exceptions.py,sha256=RjH9Jam7ONDJQ0uhWu3rtJApNybsqfi7TGtT0dlN490,2517
+lightman_ai/integrations/service_desk/integration.py,sha256=5r3bipao_apaDWLRiH4oiBJFb4c1mvo7Sj2AOQUWiFY,2895
+lightman_ai/sources/base.py,sha256=i544j1ubqhx7uKRrbuXq3yhRuRbwJgCQxCIavjznn5s,182
+lightman_ai/sources/the_hacker_news.py,sha256=qyLF4wVHJ7C2O01MGYrKej-KvPI4mHd8ntntfMksX6s,1809
+lightman_ai-0.20.1.dist-info/METADATA,sha256=LuWTKR9ZjUpexQlbBmudcc5euYmrD1DnyRWZtOFPp9w,12558
+lightman_ai-0.20.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lightman_ai-0.20.1.dist-info/entry_points.txt,sha256=9H7Ji-zxbCWAaVL5Yg4fG5va0H_5Tr2kMGGMsghaAas,60
+lightman_ai-0.20.1.dist-info/licenses/LICENSE,sha256=NhxDmY3AGgeEsYHIfDGLNkzBVX94pARRDS8H46JZ1zQ,1076
+lightman_ai-0.20.1.dist-info/RECORD,,

lightman_ai-0.20.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

lightman_ai-0.20.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lightman-ai = lightman_ai.cli:entry_point