brokit 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

brokit/__init__.py

@@ -0,0 +1,11 @@
+from brokit.primitives.lm import LM, ModelType, ModelResponse, Usage, Message
+from brokit.primitives.prompt import Prompt, InputField, OutputField, Image
+from brokit.primitives.predictor import Predictor
+from brokit.primitives.shot import Shot
+
+__all__ = [
+    "LM", "ModelType", "ModelResponse", "Usage", "Message",
+    "Prompt", "InputField", "OutputField", "Image",
+    "Predictor",
+    "Shot",
+]

{brokit-0.1.0.dist-info → brokit-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brokit
-Version: 0.1.0
+Version: 0.1.1
 Summary: brokit, think it like a playing lego
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -41,13 +41,42 @@ Zero required dependencies. Want to use `requests`, `httpx`, or `boto3`? Go for
 - Build custom LM implementations
 - Structured prompts with type hints
 
-## Getting Started
+## Installation
 
-Peep the notebooks:
-- Custom Prompt signatures
-- Your own LM implementations  
-- Few-shot examples
-- External library integrations
+```bash
+pip install brokit
+```
+
+## Quick Start
+
+```python
+import brokit as bk
+
+# Define your prompt structure
+class QA(bk.Prompt):
+    """Answer questions"""
+    question: str = bk.InputField()
+    answer: str = bk.OutputField()
+
+# Create your LM and predictor
+lm = YourLM(model_name="your-model")
+qa = bk.Predictor(prompt=QA, lm=lm)
+
+# Get results
+response = qa(question="What is brokit?")
+```
+
+## Cookbook
+
+Check out the `cookbook/` directory for hands-on examples:
+
+**LM Integrations:**
+- `lm/ollama.ipynb` - Ollama integration with vision support
+- `lm/bedrock.ipynb` - AWS Bedrock integration
+
+**Predictor Patterns:**
+- `predictor/zero_shot.ipynb` - Basic prompting and chain-of-thought
+- `predictor/few_shots.ipynb` - Few-shot learning with examples
 
 ## What's Next?
 

brokit-0.1.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+brokit/__init__.py,sha256=PiNUBJOfyF3lwJZpI4zFVdKHo2fPaw2HlMLxSTw8km4,400
+brokit-0.1.1.dist-info/licenses/LICENSE,sha256=AlKxqWygpcpUJFQMNzVQo49hRDJZV-T9f6OdCIZ-nFI,1068
+brokit-0.1.1.dist-info/METADATA,sha256=qKGLXsOsYtqTpvSAjws05pK6f6EqpnDhn3tfzYQXg-E,2169
+brokit-0.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+brokit-0.1.1.dist-info/top_level.txt,sha256=firlnp5v9hTM1UCmPUNShl-bL3V1DWqYydcaOAxR0K0,7
+brokit-0.1.1.dist-info/RECORD,,

brokit/primitives/formatter.py

@@ -1,166 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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

@@ -1,158 +0,0 @@
-"""
-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

@@ -1,48 +0,0 @@
-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/RECORD

@@ -1,12 +0,0 @@
-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,,