brokit 0.1.0__py3-none-any.whl

brokit/primitives/formatter.py

@@ -0,0 +1,166 @@
+from brokit.primitives.prompt import Prompt
+from brokit.primitives.shot import Shot
+from brokit.primitives.lm import Message
+from typing import List, Optional
+
+class PromptFormatter:
+    def __call__(
+            self, 
+            input_fields:dict,
+            output_fields:dict,
+            instructions:str,
+            inputs:dict, 
+            shots:Optional[List[Shot]]=None, 
+            special_token:str="<||{field}||>"
+        ):
+        system_prompt = []
+        input_prompt = []
+        shot_prompt = []
+        self.format_system_in_out(system_prompt, input_fields, output_fields)
+        self.format_system_structure(system_prompt, input_fields, output_fields, special_token)
+        self.format_system_instruction(system_prompt, instructions)
+        self.format_shot_prompt(shot_prompt, input_fields, output_fields, shots, special_token)
+        self.format_input_prompt(input_prompt, input_fields, output_fields, inputs, special_token)
+        return system_prompt, shot_prompt, input_prompt
+
+    def format_shot_prompt(self, shot_prompt: list, input_fields: dict, output_fields: dict, shots: Optional[List], special_token: str) -> list:
+        """Format shots as user/assistant message pairs."""
+        from brokit.primitives.lm import Message
+        
+        if not shots:
+            return shot_prompt
+        
+        for shot in shots:
+            # User message with inputs
+            user_content = []
+            for field_name in input_fields.keys():
+                value = shot.inputs.get(field_name, "")
+                user_content.append(f"{special_token.format(field=field_name)}\n{value}")
+            
+            shot_prompt.append(Message(
+                role="user",
+                content="\n".join(user_content)
+            ))
+            
+            # Assistant message with outputs
+            assistant_content = []
+            for field_name in output_fields.keys():
+                value = shot.outputs.get(field_name, "Intentionally left blank.")
+                assistant_content.append(f"{special_token.format(field=field_name)}\n{value}\n")
+            assistant_content.append(special_token.format(field="completed"))
+            
+            shot_prompt.append(Message(
+                role="assistant",
+                content="\n".join(assistant_content)
+            ))
+        
+        return shot_prompt
+
+    def _format_in_out(self, system_prompt:list, input_dict:dict)->list:
+        idx = 1
+        for field_name, field_value in input_dict.items():
+            dtype = field_value.type
+            desc = field_value.description
+            system_prompt.append(f"{idx}. {field_name} ({dtype}): {desc}")
+            idx += 1
+        return system_prompt
+
+    def format_system_in_out(self, system_prompt, input_fields, output_fields)->list:
+        if input_fields:
+            system_prompt.append("Your input fields are:")
+            self._format_in_out(system_prompt, input_fields) 
+        if output_fields:
+            system_prompt.append("Your output fields are:")
+            self._format_in_out(system_prompt, output_fields) 
+        return system_prompt
+
+    def _format_structure(self, system_prompt:list, input_dict:dict, special_token:str)->list:
+        for field_name, field_value in input_dict.items():
+            system_prompt.append(f"{special_token.format(field=field_name)}\n{{{field_name}}}\n")
+        return system_prompt
+
+    def format_system_structure(self, system_prompt:list, input_fields:dict, output_fields:dict, special_token:str)->list:
+        system_prompt.append("\nAll interactions will be structured in the following way, with the appropriate values filled in.\n")
+        self._format_structure(system_prompt, input_fields, special_token)
+        self._format_structure(system_prompt, output_fields, special_token)
+        system_prompt.append(special_token.format(field="completed"))
+        return system_prompt
+    
+    def format_system_instruction(self, system_prompt:list, instructions:str)->list:
+        system_prompt.append("In adhering to this structure, your objective is: ")
+        system_prompt.append(instructions)
+        return system_prompt
+    
+    def format_input_prompt(self, input_prompt: list, input_fields: dict, output_fields: dict, inputs: dict, special_token: str) -> list:
+        for input_name, input_value in inputs.items():
+            if input_name in input_fields:
+                input_prompt.append(f"{special_token.format(field=input_name)}\n{input_value}\n")
+        
+        input_prompt.append(
+            "Respond with the corresponding output fields, starting with the field: " +
+            ', '.join([f"`{special_token.format(field=field_name)}`" for field_name in output_fields.keys()]) +
+            f" and then ending with the marker for `{special_token.format(field='completed')}`."
+        )
+        
+        return input_prompt
+
+    # @staticmethod
+    # def format_chat(system_prompt: list, input_prompt: list, images: Optional[list] = None) -> list[Message]:
+    #     messages = []
+    #     if system_prompt:
+    #         messages.append(Message(role="system", content="\n".join(system_prompt)))
+    #     if input_prompt:
+    #         messages.append(Message(
+    #             role="user", 
+    #             content="\n".join(input_prompt),
+    #             images=images
+    #         ))
+    #     return messages   
+    @staticmethod
+    def format_chat(system_prompt: list, shot_prompt: list, input_prompt: list, images: Optional[list] = None) -> list[Message]:
+        """
+        Format messages in order: system → shots → user input.
+        
+        Args:
+            system_prompt: System instructions
+            shot_prompt: List of Message objects (user/assistant pairs)
+            input_prompt: User input
+            images: Optional images for user input
+        """
+        from brokit.primitives.lm import Message
+        
+        messages = []
+        
+        # 1. System message
+        if system_prompt:
+            messages.append(Message(role="system", content="\n".join(system_prompt)))
+        
+        # 2. Shot messages (already Message objects)
+        if shot_prompt:
+            messages.extend(shot_prompt)
+        
+        # 3. User input message
+        if input_prompt:
+            messages.append(Message(
+                role="user",
+                content="\n".join(input_prompt),
+                images=images
+            ))
+        
+        return messages
+
+    @staticmethod
+    def parse_prediction(response:str, output_fields:dict, special_token:str="<||{field}||>")->dict:
+        outputs = {}
+        for field_name in output_fields.keys():
+            start_token = special_token.format(field=field_name)
+            end_token = special_token.format(field="completed")
+            start_idx = response.find(start_token)
+            if start_idx != -1:
+                start_idx += len(start_token)
+                end_idx = response.find(end_token, start_idx)
+                if end_idx == -1:
+                    end_idx = len(response)
+                field_value = response[start_idx:end_idx].strip()
+                outputs[field_name] = field_value
+        return outputs

brokit/primitives/lm.py

@@ -0,0 +1,115 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Optional, Any, Literal
+from dataclasses import dataclass
+from enum import Enum
+import time
+from collections import OrderedDict
+import json
+import hashlib
+
+class ModelType(str, Enum):
+    CHAT = "chat"
+    # COMPLETION = "completion" # not implement yet
+
+@dataclass
+class Message:
+    role: Literal["system", "user", "assistant"]
+    content: str
+    images: Optional[List[Any]] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict for serialization."""
+        d: Dict[str, Any] = {"role": self.role, "content": self.content}
+        if self.images:
+            d["images"] = self.images
+        return d
+
+@dataclass
+class Usage:
+    input_tokens: int
+    output_tokens: int
+
+@dataclass
+class ModelResponse:
+    model_name:str
+    model_type:ModelType
+    response:str
+    usage:Usage
+    response_ms: Optional[float] = None
+    cached:bool = False
+    metadata:Optional[Dict[str, Any]] = None
+    request:Optional[Dict[str, Any]] = None
+    parsed_response: Optional[Dict[str, Any]] = None
+
+class LM(ABC):
+    def __init__(self, model_name: str, model_type:ModelType, cache_size:int=10):
+        self.model_name = model_name
+        self.model_type = model_type
+        self._cache = OrderedDict()
+        self._cache_size = cache_size
+        self.history = []
+
+    @abstractmethod    
+    def request(self, prompt:Optional[str]=None, messages:Optional[List[Message]]=None, **kwargs) -> Any:
+        raise NotImplementedError
+
+    @abstractmethod
+    def parse_response(self, original_response:dict) -> ModelResponse:
+        raise NotImplementedError
+
+    def _validate_input(self, prompt:Optional[str], messages:Optional[List[Message]]):
+        if prompt is None and messages is None:
+            raise ValueError("Either prompt or messages must be provided")
+        if prompt is not None and messages is not None:
+            raise ValueError("Cannot provide both prompt and messages")
+
+    def _cache_key(self, prompt: Optional[str], messages: Optional[List[Message]], kwargs: dict) -> str:
+        """Generate cache key from request parameters."""
+        # Convert messages to serializable format
+        serializable_messages = None
+        if messages:
+            serializable_messages = [
+                {
+                    "role": msg.role,
+                    "content": msg.content,
+                    "images": msg.images
+                } if isinstance(msg, Message) else msg
+                for msg in messages
+            ]
+        
+        cache_data = {
+            "model": self.model_name,
+            "prompt": prompt,
+            "messages": serializable_messages,
+            **kwargs
+        }
+        # Convert to JSON string (sorted for consistency)
+        json_str = json.dumps(cache_data, sort_keys=True)
+        # Hash to fixed-length key
+        return hashlib.sha256(json_str.encode()).hexdigest()    
+
+    def __call__(self, prompt: Optional[str] = None, messages: Optional[List[Message]] = None, **kwargs) -> ModelResponse:
+        self._validate_input(prompt, messages)
+        key = self._cache_key(prompt, messages, kwargs)
+        # Check cache
+        if key in self._cache:
+            self._cache.move_to_end(key)  # Mark as recently used
+            cached_response = self._cache[key]
+            cached_response.cached = True
+            return cached_response
+
+        # Automatic timing
+        start = time.perf_counter()
+        original_response = self.request(prompt=prompt, messages=messages, **kwargs)
+        elapsed_ms = (time.perf_counter() - start) * 1000
+        
+        # Parse response
+        schema_response = self.parse_response(original_response)
+        
+        # Inject timing
+        schema_response.response_ms = elapsed_ms
+        # Add to cache with LRU eviction
+        self._cache[key] = schema_response
+        if len(self._cache) > self._cache_size:
+            self._cache.popitem(last=False)  # Remove oldest        
+        return schema_response

brokit/primitives/predictor.py

@@ -0,0 +1,109 @@
+from brokit.primitives.prompt import Prompt
+from brokit.primitives.lm import LM, ModelType, ModelResponse
+from typing import Type, List, Optional, Any
+import re
+from brokit.primitives.formatter import PromptFormatter
+from brokit.primitives.prompt import Image
+from brokit.primitives.shot import Shot
+
+def parse_outputs(response: str, output_fields: dict, special_token: str = "<||{field}||>") -> dict:
+    """Parse LM response with dynamic special tokens."""
+    outputs = {}
+    
+    # Extract prefix and suffix from special_token template
+    # e.g., "<||{field}||>" -> prefix="<||", suffix="||>"
+    prefix, suffix = special_token.split("{field}")
+    
+    for field_name in output_fields.keys():
+        # Escape special regex chars and build pattern
+        escaped_prefix = re.escape(prefix)
+        escaped_suffix = re.escape(suffix)
+        pattern = rf"{escaped_prefix}{field_name}{escaped_suffix}\s*\n(.*?)(?={escaped_prefix}|$)"
+        
+        match = re.search(pattern, response, re.DOTALL)
+        if match:
+            outputs[field_name] = match.group(1).strip()
+    
+    return outputs
+
+class Prediction:
+    def __init__(self, **kwargs: Any) -> None:
+        self._data = kwargs
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+    
+    def __repr__(self) -> str:
+        items = ",\n    ".join(f"{k}={v!r}" for k, v in self._data.items())
+        return f"Prediction(\n    {items}\n)"
+    
+    def __getattr__(self, name: str) -> Any:
+        raise AttributeError(f"'{type(self).__name__}' has no attribute '{name}'")
+
+    def to_dict(self) -> dict:
+        return self._data        
+
+class Predictor:
+    def __init__(self, prompt: Type[Prompt], lm:Optional[LM]=None, shots:Optional[list[Shot]]=None):
+        self.prompt = prompt
+        self.lm = lm
+        self.shots = shots
+        self.prompt_formatter = PromptFormatter()
+
+    def structure_output(self, response: ModelResponse, output_fields, special_token: str = "<||{field}||>") -> Prediction:
+        output = parse_outputs(response.response, output_fields, special_token)
+        
+        # Convert types based on field definitions
+        converted = {}
+        for field_name, value in output.items():
+            if field_name in output_fields:
+                field_type = output_fields[field_name].type
+                converted[field_name] = self._convert_type(value, field_type)
+            else:
+                converted[field_name] = value
+        
+        return Prediction(**converted)
+
+    def _convert_type(self, value: str, target_type: type):
+        """Convert string value to target type."""
+        if target_type == str:
+            return value
+        elif target_type == int:
+            return int(value.strip())
+        elif target_type == float:
+            return float(value.strip())
+        elif target_type == bool:
+            return value.strip().lower() in ('true', '1', 'yes')
+        elif target_type == list:
+            # Simple list parsing - can be enhanced
+            return [item.strip() for item in value.strip('[]').split(',')]
+        else:
+            return value
+
+    def _call_chat(self, lm, system_prompt, shot_prompt, input_prompt, images):
+        messages = self.prompt_formatter.format_chat(system_prompt, shot_prompt, input_prompt, images)
+        response = lm(messages=messages)
+        output = self.structure_output(response, self.prompt.output_fields)
+        response.parsed_response = output.to_dict()
+        response.request = messages
+        lm.history.append(response)
+        return output
+
+    def __call__(self, images: Optional[list[Image]]=None, **kwargs):
+        # prompt_instance = self.prompt.to_dict()
+        input_fields = self.prompt.input_fields
+        output_fields = self.prompt.output_fields
+        instructions = self.prompt.instructions
+        lm = self.lm
+        system_prompt, input_prompt, shot_prompt = self.prompt_formatter(input_fields, output_fields, instructions, kwargs, self.shots)
+
+        base64_images = None
+        if images:
+            from brokit.primitives.prompt import Image
+            base64_images = [
+                img.to_base64() if isinstance(img, Image) else img 
+                for img in images
+            ]
+
+        if lm.model_type == ModelType.CHAT:
+            return self._call_chat(lm, system_prompt, input_prompt, shot_prompt, base64_images)
+        raise NotImplementedError("Only CHAT model type is implemented.")

brokit/primitives/prompt.py

@@ -0,0 +1,158 @@
+"""
+Prompt is where we keep the prompt contract for the program
+
+What should Prompt do:
+- construct new class from MetaClass concept
+- in new class, have input_fields, output_fields, instructions as properties
+- the class itself should be composable with/without output_fields
+- Prompt is simply the way to construct the prompt which will be formatted later with Predictor
+- Since prompt here has both input/output, I think we can make used of it as example or demo?
+"""
+
+from dataclasses import dataclass
+from typing import Type, Any, Dict, Union
+import base64
+from pathlib import Path
+import httpx
+import mimetypes
+
+class Image:
+    def __init__(self, source: Union[str, bytes, Path]):
+        """
+        Initialize Image from path, URL, or bytes.
+        
+        Args:
+            source: File path, URL (http/https), or raw bytes
+        """
+        self.source = source
+        if isinstance(source, bytes):
+            self._base64 = base64.b64encode(source).decode('utf-8')
+            self._mime_type = "image/jpeg"  # Default
+        elif isinstance(source, (str, Path)):
+            source_str = str(source)
+            if source_str.startswith(('http://', 'https://')):
+                self._base64 = self._from_url(source_str)
+                self._mime_type = "image/jpeg"
+            else:
+                self._base64 = self._from_path(source_str)
+                self._mime_type = mimetypes.guess_type(source_str)[0] or "image/jpeg"
+        else:
+            raise ValueError(f"Unsupported source type: {type(source)}")
+    
+    def _from_path(self, path: str) -> str:
+        """Load image from file path."""
+        with open(path, 'rb') as f:
+            return base64.b64encode(f.read()).decode('utf-8')
+    
+    def _from_url(self, url: str) -> str:
+        """Download image from URL."""
+        response = httpx.get(url)
+        response.raise_for_status()
+        return base64.b64encode(response.content).decode('utf-8')
+    
+    def to_base64(self) -> str:
+        """Get base64 encoded string."""
+        return self._base64
+    
+    def __repr__(self) -> str:
+        """DSPy-style representation."""
+        data_url = f"data:{self._mime_type};base64,<IMAGE_BASE64_ENCODED({len(self._base64)})>"
+        return f"Image(url={data_url})"
+
+@dataclass
+class FieldInfo:
+    name: str
+    description: str
+    type: Type
+    is_input: bool
+    
+def InputField(description:str = "") -> Any:
+    return FieldInfo(name="", description=description, type=str, is_input=True)
+
+def OutputField(description:str = "") -> Any:
+    return FieldInfo(name="", description=description, type=str, is_input=False)
+
+class PromptMeta(type):
+    # Add type hints for metaclass attributes
+    _input_fields: Dict[str, FieldInfo]
+    _output_fields: Dict[str, FieldInfo]
+    _instructions: str    
+    def __new__(cls, name, bases, namespace):
+        # Check if this is from from_dict (already processed)
+        if '_input_fields' in namespace and '_output_fields' in namespace and '_instructions' in namespace:
+            # Already processed, just create the class
+            return super().__new__(cls, name, bases, namespace)        
+        input_fields = {}
+        output_fields = {}
+        # Get type annotations
+        annotations = namespace.get('__annotations__', {})
+        for field_name, field_value in list(namespace.items()):
+            if isinstance(field_value, FieldInfo):
+                field_value.name = field_name
+                
+                # Extract type from annotation
+                if field_name in annotations:
+                    field_value.type = annotations[field_name]
+                
+                if field_value.is_input:
+                    input_fields[field_name] = field_value
+                else:
+                    output_fields[field_name] = field_value
+                
+                del namespace[field_name]
+        
+        namespace['_input_fields'] = input_fields
+        namespace['_output_fields'] = output_fields
+        namespace['_instructions'] = (namespace.get('__doc__', '') or '').strip()
+        return super().__new__(cls, name, bases, namespace)
+    
+    @property
+    def input_fields(cls):
+        return cls._input_fields
+    
+    @property
+    def output_fields(cls):
+        return cls._output_fields
+    
+    @property
+    def instructions(cls):
+        return cls._instructions
+
+class Prompt(metaclass=PromptMeta):
+    
+    """Base class for defining prompts with input and output fields."""
+    # Type hints for class attributes set by metaclass
+    _input_fields: Dict[str, FieldInfo]
+    _output_fields: Dict[str, FieldInfo]
+    _instructions: str     
+
+    def __init__(self, **kwargs):
+        for name, value in kwargs.items():
+            if name in self._input_fields or name in self._output_fields:
+                setattr(self, name, value)
+            else:
+                raise ValueError(f"Unknown field: {name}")
+        
+        for name in self._input_fields:
+            if name not in kwargs:
+                raise ValueError(f"Missing required input: {name}")
+    
+    def __getattr__(self, name):
+        if name in self._output_fields:
+            return "Intentionally left blank."
+        raise AttributeError(f"'{type(self).__name__}' has no attribute '{name}'")
+    
+    @property
+    def inputs(self):
+        """Get all input values (X)."""
+        return {name: getattr(self, name) for name in self._input_fields}
+    
+    @property
+    def outputs(self):
+        """Get all output values (y)."""
+        return {name: getattr(self, name) for name in self._output_fields 
+                if hasattr(self, name)}
+    
+    def is_complete(self):
+        """Check if all outputs are provided."""
+        return len(self.outputs) == len(self._output_fields)    

brokit/primitives/shot.py

@@ -0,0 +1,48 @@
+from brokit.primitives.prompt import Prompt
+from typing import Optional, Type
+
+class Shot:
+    def __init__(self, prompt_class:Optional[Type[Prompt]]=None, **kwargs):
+        """
+        Create a shot with automatic input/output separation.
+        
+        Args:
+            prompt_class: Optional Prompt class to validate fields
+            **kwargs: Field values
+        """
+        self._prompt_class = prompt_class
+        self._data = kwargs
+        
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+    
+    @property
+    def inputs(self):
+        """Get input fields based on prompt class."""
+        if self._prompt_class:
+            return {k: v for k, v in self._data.items() 
+                    if k in self._prompt_class.input_fields}
+        return {}
+    
+    @property
+    def outputs(self):
+        """Get output fields with defaults for missing ones."""
+        if self._prompt_class:
+            result = {}
+            for field_name in self._prompt_class.output_fields.keys():
+                if field_name in self._data:
+                    result[field_name] = self._data[field_name]
+                else:
+                    result[field_name] = "Intentionally left blank."
+            return result
+        return {}
+    
+    def __getattr__(self, name):
+        # Return default for missing output fields
+        if self._prompt_class and name in self._prompt_class.output_fields:
+            return "Intentionally left blank."
+        raise AttributeError(f"'{type(self).__name__}' has no attribute '{name}'")
+    
+    def __repr__(self):
+        items = ", ".join(f"{k}={v!r}" for k, v in self._data.items())
+        return f"Shot({items})"

brokit-0.1.0.dist-info/METADATA

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: brokit
+Version: 0.1.0
+Summary: brokit, think it like a playing lego
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# brokit
+
+Inspired by big bro DSPy, brokit is a minimal Python toolkit of composable, LEGO-like primitives for working with language models. Build what you need, skip the bloat.
+
+## What's This About?
+
+A lightweight library for working with LMs across any use case. Just the essential building blocks, nothing more.
+
+## Core Concepts
+
+Coming from DSPy? You already know what's up:
+
+- **Prompt** = `dspy.Signature` — Define your input/output structure
+- **Predictor** = `dspy.Predict` — Execute prompts with your LM
+- **LM** = `dspy.LM` — Language model interface
+- **Shot** — Few-shot examples made simple
+
+## Design Philosophy
+
+### Plug and Play
+
+Everything's a base class. Compose, extend, swap out whatever you want. The LM module? Bring your own.
+
+### Pure Python
+
+Zero required dependencies. Want to use `requests`, `httpx`, or `boto3`? Go for it. Check the notebooks for integration examples.
+
+## Features
+
+- Text and image support (more formats coming)
+- Few-shot learning with Shot
+- Build custom LM implementations
+- Structured prompts with type hints
+
+## Getting Started
+
+Peep the notebooks:
+- Custom Prompt signatures
+- Your own LM implementations  
+- Few-shot examples
+- External library integrations
+
+## What's Next?
+
+Check out [ROADMAP.md](ROADMAP.md) for what's coming and [VERSIONS.md](VERSIONS.md) for release notes.

brokit-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+brokit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+brokit/primitives/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+brokit/primitives/formatter.py,sha256=7VNl5A8on3IyYbyEx5NZbELPT6yefs6VEdpjmQue6kw,7199
+brokit/primitives/lm.py,sha256=XkF4lqO0vNJ23GQYBQeUKqZSuSXT_UysJjQRmXDyn_A,4022
+brokit/primitives/predictor.py,sha256=RQJseDpoX9UQqSqrfBO1kMvLro8wCy85hs2-zMqh9ck,4460
+brokit/primitives/prompt.py,sha256=k3L01nagAzWKy4UkP8pBOee2JnVOFMyX-gU71QLnz4U,5780
+brokit/primitives/shot.py,sha256=9vgmbfIM3NN5tO5Famewi9SYwGFlRr3170-MmgGSUjI,1702
+brokit-0.1.0.dist-info/licenses/LICENSE,sha256=AlKxqWygpcpUJFQMNzVQo49hRDJZV-T9f6OdCIZ-nFI,1068
+brokit-0.1.0.dist-info/METADATA,sha256=Ai4290Q1LCl9maGniyXRVspC2ascS_rhytj5wKid7EA,1547
+brokit-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+brokit-0.1.0.dist-info/top_level.txt,sha256=firlnp5v9hTM1UCmPUNShl-bL3V1DWqYydcaOAxR0K0,7
+brokit-0.1.0.dist-info/RECORD,,

brokit-0.1.0.dist-info/WHEEL

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

brokit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 datanooblol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

brokit-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+brokit