brewcli 0.1.0__py3-none-any.whl

brewcli/__main__.py

@@ -0,0 +1,4 @@
+from .cli import cli
+
+if __name__ == "__main__":
+    cli()

brewcli/brewery.py

@@ -0,0 +1,120 @@
+"""This module contains functions for calling Open Brewery DB API"""
+
+from typing import Any
+
+import httpx
+
+from brewcli.models import SearchQuery
+
+BASE_URL = "https://api.openbrewerydb.org/v1/breweries"
+HEADERS = {
+    "Accept": "application/json",
+}
+
+
+class BreweryAPI:
+    """
+    A class to interact with the Open Brewery DB API using httpx.
+
+    This class provides methods to perform API requests, such as fetching
+    random breweries and getting details for a specific brewery by ID.
+    """
+
+    def __init__(self, base_url: str = BASE_URL):
+        """
+        Initializes the BreweryAPI object with the base URL.
+
+        Args:
+            base_url (str): The base URL for the API. Defaults to Open Brewery DB URL.
+        """
+        self.base_url: str = base_url
+        self.client: httpx.Client
+        self.headers = HEADERS
+
+    def __enter__(self) -> "BreweryAPI":
+        """Initializes the HTTP client when entering the context."""
+        self.client = httpx.Client(headers=self.headers)
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        """Ensures the HTTP client is closed when exiting the context."""
+        if self.client:
+            self.client.close()
+
+    def _handle_request(
+        self, endpoint: str | None = None, params: dict | None = None
+    ) -> Any:
+        """
+        Internal method to handle GET requests to the API.
+
+        Args:
+            endpoint (str): The API endpoint to call.
+            params (dict): Any query parameters to include in the request.
+
+        Returns:
+            Any: The JSON response from the API.
+
+        Raises:
+            httpx.HTTPError: If the request fails.
+            ValueError: If the response cannot be parsed as JSON.
+        """
+
+        url = f"{self.base_url}/{endpoint}" if endpoint else self.base_url
+
+        try:
+            response = self.client.get(url, params=params)
+            response.raise_for_status()
+        except httpx.HTTPError as exc:
+            raise httpx.HTTPError(f"Error while requesting {url}.") from exc
+
+        try:
+            return response.json()
+        except ValueError as exc:
+            raise ValueError(f"Failed to return json response from {url}") from exc
+
+    def get_random_breweries(self, number: int = 1) -> Any:
+        """
+        Fetches a specified number of random breweries from the Open Brewery DB API.
+
+        Args:
+            number (int): The number of random brewery results to return. Defaults to 1.
+
+        Returns:
+            list[dict]: A list of brewery details as dictionaries.
+        """
+        return self._handle_request(endpoint="random", params={"size": number})
+
+    def get_brewery_by_id(self, brewery_id: str) -> Any:
+        """
+        Fetches a single brewery by its ID.
+
+        Args:
+            brewery_id (str): The ID of the brewery to fetch.
+
+        Returns:
+            dict: The brewery details.
+        """
+        return self._handle_request(brewery_id)
+
+    def get_brewery_filters(self, search_query: SearchQuery) -> Any:
+        """
+        Fetches a list of breweries based on the specified search query filters.
+
+        This method constructs the necessary query parameters from the provided
+        `SearchQuery` object and sends a request to the Open Brewery DB API to
+        retrieve breweries that match the search criteria.
+
+        Args:
+            search_query (SearchQuery): An object containing search filters to be
+                                        applied to the brewery search.
+
+        Returns:
+            Any: The JSON response from the API, typically a list of breweries
+                that match the search query.
+
+        Raises:
+            httpx.HTTPError: If the request to the API fails.
+            ValueError: If the response cannot be parsed as JSON.
+        """
+        params = search_query.to_params()
+        return self._handle_request(params=params)

brewcli/cli.py

@@ -0,0 +1,112 @@
+import click
+from httpx import HTTPError
+
+from .brewery import BreweryAPI
+from .models import BREWERY_TYPES, Brewery, Coordinate, SearchQuery
+
+
+@click.group()
+def cli() -> None:
+    """
+    A simple CLI that retrieves random breweries and displays their name, location,
+    and a link to their website.
+
+    Provide a number specifying how many breweries you would like!
+    """
+
+
+@cli.command()
+@click.argument("number", type=click.IntRange(min=1))
+def random(number: int) -> None:
+    """
+    Retrieve a random set of breweries.
+
+    Args:
+        number (int): The number of random breweries to retrieve.
+    """
+    with BreweryAPI() as client:
+        try:
+            breweries: list[Brewery] = [
+                Brewery.from_dict(brewery)
+                for brewery in client.get_random_breweries(number=number)
+            ]
+        except HTTPError as exc:
+            click.echo(f"HTTP Exception for {exc.request.url} - {exc}", err=True)
+            return
+        except (KeyError, TypeError) as exc:
+            click.echo(
+                f"Error occurred while instantiating Brewery from response data: {exc}",
+                err=True,
+            )
+            return
+
+    for brewery in breweries:
+        click.echo(brewery)
+        click.echo()
+
+
+@cli.command()
+@click.argument("brewery_id", type=click.STRING)
+def by_id(brewery_id: str) -> None:
+    """Retrieve a brewery by ID"""
+    with BreweryAPI() as client:
+        try:
+            data: dict = client.get_brewery_by_id(brewery_id=brewery_id)
+            brewery: Brewery = Brewery.from_dict(data)
+        except (KeyError, TypeError) as exc:
+            click.echo(f"Error occurred creating Brewery from response data: {exc}")
+            return
+        except HTTPError as exc:
+            click.echo(f"HTTP Exception for {exc.request.url} - {exc}", err=True)
+            return
+
+    click.echo(brewery)
+
+
+@cli.command()
+@click.option("--by-city", type=click.STRING)
+@click.option("--by-country", type=click.STRING)
+@click.option("--by-dist", type=click.STRING, help="Coordinates as 'lat,lon'")
+@click.option("--by-name", type=click.STRING)
+@click.option("--by-postal", type=click.STRING)
+@click.option("--by-state", type=click.STRING)
+@click.option("--by-type", type=click.Choice(BREWERY_TYPES, case_sensitive=False))
+def search(**filters: str | None) -> None:
+    """Retrieve a set of breweries using one or more search terms."""
+    by_dist = filters.pop("by_dist")
+    coord = None
+    if by_dist:
+        try:
+            coord = Coordinate.from_str(by_dist)
+        except ValueError as exc:
+            click.echo(f"Invalid --by-dist value: {exc}", err=True)
+            return
+
+    # Map remaining --by-* options (e.g. by_city) to SearchQuery fields (city).
+    fields = {key.removeprefix("by_"): value for key, value in filters.items()}
+    query = SearchQuery(coord=coord, **fields)
+
+    with BreweryAPI() as client:
+        try:
+            results = client.get_brewery_filters(query)
+        except HTTPError as exc:
+            click.echo(f"HTTP Exception: {exc}", err=True)
+            return
+
+    if not results:
+        click.echo("No breweries found.")
+        return
+
+    for data in results:
+        try:
+            brewery = Brewery.from_dict(data)
+        except (KeyError, TypeError) as exc:
+            click.echo(f"Error parsing brewery: {exc}", err=True)
+            continue
+        click.echo(brewery)
+        click.echo()
+
+
+cli.add_command(random)
+cli.add_command(by_id)
+cli.add_command(search)

brewcli/logging.py

@@ -0,0 +1,20 @@
+import json
+import logging
+from pathlib import Path
+
+BASE_DIR = Path(__file__).parent
+CONFIG_PATH = BASE_DIR / "logging_config.json"
+LOG_FILE_PATH = BASE_DIR / "brewcli.log"
+
+
+def setup_logging():
+    """Setup logging from a JSON config file."""
+    with CONFIG_PATH.open("r") as f:
+        config = json.load(f)
+
+    # Ensures the log file directory exists
+    LOG_FILE_PATH.touch(exist_ok=True)
+
+    # Set up Queues for async logging
+
+    logging.config.dictConfig(config)

brewcli/models.py

@@ -0,0 +1,392 @@
+"""Module providing data objects"""
+
+import logging
+from dataclasses import dataclass, fields
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Coordinate:
+    """
+    Represents a geographic coordinate with latitude and longitude values.
+
+    This class ensures that both latitude and longitude values are float-compatible and
+    within the valid range of -180 to 180.
+
+    Attributes:
+        latitude (float): The latitude of the coordinate,
+            a float value in the range [-180, 180].
+        longitude (float): The longitude of the coordinate,
+            a float value in the range [-180, 180].
+
+    Methods:
+        to_str() -> str: Returns a string representation of the coordinate in the
+        format "<latitude>,<longitude>".
+
+    Raises:
+        ValueError: If the latitude or longitude is not convertible to a float or is
+                    out of the valid range.
+        TypeError: If the latitude or longitude is of type `None`.
+    """
+
+    latitude: float
+    longitude: float
+
+    def __post_init__(self):
+        for f in fields(self):
+            value = getattr(self, f.name)
+            try:
+                value = float(value)
+                setattr(self, f.name, value)
+            except ValueError as exc:
+                raise ValueError(f"Cannot convert {f.name}={value!r} to float") from exc
+            except TypeError as exc:
+                raise TypeError(f"Cannot accept NoneType {f.name}={value!r}") from exc
+            if abs(value) > 180:
+                raise ValueError(
+                    "Coordinate values must be within interval [-180, 180]"
+                )
+
+    def to_str(self) -> str:
+        """
+        Returns a string representation of the coordinate.
+
+        Returns:
+            str: A string in the format "<latitude>,<longitude>".
+
+        Example:
+            >>> coord = Coordinate(latitude=45.0, longitude=-93.0)
+            >>> coord.to_str()
+            '45.0,-93.0'
+        """
+        return f"{self.latitude},{self.longitude}"
+
+    @classmethod
+    def from_str(cls, coordinate: str):
+        """
+        Creates an instance from a string containing the latitude and longitude
+        separated by a comma.
+
+        Attributes:
+            coordinate (str): String representing a coordinate of the
+                form "<latitude>,<longitude>"
+        """
+
+        # Try to split on comma and should have exactly 2 elements
+        # Trim whitespace
+        # Try to convert each element to a float
+        # If successfully converted to floats return a Coordinate object
+
+        try:
+            lat_long = [s.strip() for s in coordinate.split(",")]
+
+            if len(lat_long) != 2:
+                raise ValueError("Input must be in the format '<latitude>,<longitude>'")
+
+            lat, long = float(lat_long[0]), float(lat_long[1])
+
+            return cls(lat, long)
+
+        except ValueError as exc:
+            raise ValueError(
+                f"Invalid coordinate format: {coordinate}. Error: {exc}"
+            ) from exc
+
+
+@dataclass
+class Address:
+    """
+    Represents a physical address and its associated geographic coordinate.
+
+    This class contains attributes to define a complete address and an optional
+    geographic coordinate (latitude and longitude).
+
+    Attributes:
+        address_one (str): The primary address line.
+        address_two (str | None): The secondary address line, if any.
+        address_three (str | None): The tertiary address line, if any.
+        street (str): The street name.
+        city (str): The city where the address is located.
+        state (str): The state or province of the address.
+        postal_code (str): The postal or ZIP code.
+        country (str): The country of the address.
+        coordinate (Coordinate | None): The geographic coordinate of the address,
+            represented as a `Coordinate` object. Can be `None` if not provided.
+
+    Methods:
+        from_dict(data: dict) -> Address:
+            Creates an `Address` object from a dictionary of attributes.
+    """
+
+    address_one: str
+    street: str
+    city: str
+    state: str
+    postal_code: str
+    country: str
+    address_two: str | None = None
+    address_three: str | None = None
+    coordinate: Coordinate | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        """
+        Create and Address object from dictionary.
+        """
+        try:
+            coordinate = Coordinate(
+                longitude=data["longitude"], latitude=data["latitude"]
+            )
+        except (ValueError, KeyError, TypeError) as exc:
+            logger.warning(
+                "Could not create coordinate for %s: %s", data.get("name"), exc
+            )
+            coordinate = None
+        return cls(
+            address_one=data["address_1"],
+            address_two=data.get("address_2"),
+            address_three=data.get("address_3"),
+            street=data["street"],
+            city=data["city"],
+            state=data["state"],
+            postal_code=data["postal_code"],
+            country=data["country"],
+            coordinate=coordinate,
+        )
+
+
+@dataclass
+class Brewery:
+    """
+    Represents a brewery and its associated details.
+
+    This class encapsulates information about a brewery, including its ID, name,
+    address, contact details, and website URL.
+
+    Attributes:
+        id (str): The unique identifier of the brewery.
+        name (str): The name of the brewery.
+        address (Address): The address of the brewery, represented as an `Address`
+            object.
+        phone (str): The phone number of the brewery.
+        website_url (str): The website URL of the brewery.
+
+    Methods:
+        from_dict(data: dict) -> Brewery:
+            Creates a `Brewery` object from a dictionary of attributes.
+    """
+
+    id: str
+    name: str
+    brewery_type: str
+    address: Address
+    phone: str | None
+    website_url: str | None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Brewery":
+        """
+        Creates a `Brewery` object from a dictionary.
+
+        Args:
+            data (dict): A dictionary containing the brewery data. Expected
+            keys include:
+                - "id" (str): The brewery's unique identifier.
+                - "name" (str): The brewery's name.
+                - "brewery_type" (str): Type of brewery.
+                - "address_1", "address_2", "address_3", "street", "city", "state",
+                    "postal_code", "country": Address details passed to `
+                    Address.from_dict`.
+                - "latitude", "longitude" (float): Geographic coordinates
+                     of the brewery.
+                - "phone" (str): The brewery's phone number.
+                - "website_url" (str): The brewery's website URL.
+
+        Returns:
+            Brewery: An instance of the `Brewery` class.
+
+        Raises:
+            KeyError: If required fields are missing in the input data.
+            TypeError: If the input data is not a dictionary or contains i
+            ncorrect types.
+
+        Example:
+            >>> data = {
+            ...     "id": "b54b16e1-ac3b-4bff-a11f-f7ae9ddc27e0",
+            ...     "name": "MadTree Brewing 2.0",
+            ...     "brewery_type": "large",
+            ...     "address_1": "5164 Kennedy Ave",
+            ...     "city": "Cincinnati",
+            ...     "state": "Ohio",
+            ...     "postal_code": "45213",
+            ...     "country": "United States",
+            ...     "latitude": 39.1885752,
+            ...     "longitude": -84.4137736,
+            ...     "phone": "5138368733",
+            ...     "website_url": "http://www.madtreebrewing.com",
+            ... }
+            >>> brewery = Brewery.from_dict(data)
+            >>> brewery.phones
+            '5138368733'
+        """
+        address = Address.from_dict(data)
+        return cls(
+            id=data["id"],
+            name=data["name"],
+            brewery_type=data["brewery_type"],
+            address=address,
+            phone=data.get("phone"),
+            website_url=data.get("website_url"),
+        )
+
+    def to_flat_dict(self) -> dict:
+        """Returns a flattened dictionary from Brewery instance."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "brewery_type": self.brewery_type,
+            "phone": self.phone,
+            "website_url": self.website_url,
+            "address_one": self.address.address_one,
+            "address_two": self.address.address_two,
+            "address_three": self.address.address_three,
+            "postal_code": self.address.postal_code,
+            "city": self.address.city,
+            "state": self.address.state,
+            "country": self.address.country,
+            "street": self.address.street,
+            "latitude": self.address.coordinate.latitude
+            if self.address.coordinate
+            else None,
+            "longitude": self.address.coordinate.longitude
+            if self.address.coordinate
+            else None,
+        }
+
+
+class BreweryType(Enum):
+    MICRO = "micro"
+    NANO = "nano"
+    REGIONAL = "regional"
+    BREWPUB = "brewpub"
+    PLANNING = "planning"
+    CONTRACT = "contract"
+    PROPRIETOR = "proprietor"
+    CLOSED = "closed"
+
+
+BREWERY_TYPES = [t.value for t in BreweryType]
+
+
+@dataclass
+class SearchQuery:
+    """
+    Represents a set of search parameters for querying the OD Brewery API
+    in a form it excpects.c
+
+    This class captures user input, validates certain parameters, and provides
+    a method to convert the data into a dictionary suitable for use as query
+    parameters in API requests.
+
+    Attributes:
+        by_city (str | None): The city to filter the search results by.
+        by_country (str | None): The country to filter the search results by.
+        by_dist (str | None): A string representing distance in the format
+            "latitude,longitude".
+        by_name (str | None): The name of the brewery to search for.
+        by_state (str | None): The state to filter the search results by.
+        postal (str | None): The postal code to filter the search results by.
+        type (BreweryType | None): The type of brewery to filter results by.
+        sort_order (str | None): The sorting order for the results,
+            either 'asc' or 'desc'.
+        by_ids (list[str] | None): A list of brewery IDs to filter the search
+            results by.
+        page (int | None): The page number for paginated results. Defaults to 1.
+        per_page (int | None): The number of results per page. Defaults to 50, with
+            a maximum value of 200.
+
+    Methods:
+        __post_init__(): Validates the parameters, ensuring sort_order is either
+            'asc' or 'desc', page is 1 or greater, and per_page is between 1 and 200.
+        to_params() -> dict: Converts the dataclass fields into a dictionary of
+            query parameters, excluding any fields with a value of `None`.
+    """
+
+    city: str | None = None
+    country: str | None = None
+    coord: Coordinate | None = None
+    name: str | None = None
+    state: str | None = None
+    postal: str | None = None
+    type: str | None = None
+    sort_order: str | None = None
+    ids: list[str] | None = None
+    page: int | None = 1
+    per_page: int | None = 50  # Default 50, max 200
+
+    def __post_init__(self):
+        if self.sort_order is not None and self.sort_order not in ["asc", "desc"]:
+            raise ValueError(
+                f"Invalid sort_order '{self.sort_order}'. Must be 'asc', 'desc', "
+                "or None."
+            )
+        if (self.page is not None) and (
+            not isinstance(self.page, int) or self.page < 1
+        ):
+            raise ValueError(
+                f"Invalid page: {self.page}. Must be an integer greater than "
+                "or equal to 1."
+            )
+        if (self.per_page is not None) and (
+            not isinstance(self.per_page, int) or not 1 <= self.per_page <= 200
+        ):
+            raise ValueError(
+                f"Invalid per_page: {self.per_page}. Must be an integer "
+                "from 1 to 200."
+            )
+        if self.type is not None and self.type not in BREWERY_TYPES:
+            raise ValueError(
+                f"Invalid value for type: {self.type}. Must be one of "
+                f"{', '.join(BREWERY_TYPES)}",
+            )
+        if self.coord is not None and not isinstance(self.coord, Coordinate):
+            raise ValueError(
+                f"Invalid value for by_dist: {type(self.coord)}. Must be of "
+                "type Coordinate."
+            )
+
+    def to_params(self) -> dict:
+        """
+        Converts the SearchQuery instance into a dictionary of query parameters.
+
+        This method constructs a dictionary by mapping the dataclass attributes
+        to their respective API query parameter names. Fields with `None` values
+        are excluded from the final dictionary.
+
+        Returns:
+            dict: A dictionary of query parameters suitable for use in API requests.
+
+        Example:
+            >>> query = SearchQuery(city="Denver", country="US", page=2)
+            >>> query.to_params()
+            {'by_city': 'Denver', 'by_country': 'US', 'page': 2}
+        """
+        params = {
+            "by_city": self.city,
+            "by_country": self.country,
+            "by_dist": self.coord.to_str()
+            if isinstance(self.coord, Coordinate)
+            else None,
+            "by_ids": ",".join(self.ids) if self.ids else None,
+            "by_name": self.name,
+            "by_state": self.state,
+            "by_postal": self.postal,
+            "by_type": self.type,
+            "page": self.page,
+            "per_page": self.per_page,
+            "sort_order": self.sort_order,
+        }
+        # Remove keys with `None` values
+        return {k: v for k, v in params.items() if v is not None}

brewcli/utils.py

@@ -0,0 +1,3 @@
+def save_data(data: list[dict] | dict, file_type: str, filepath: str):
+    # if file_type is "json" sa
+    pass

brewcli-0.1.0.dist-info/METADATA

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: brewcli
+Version: 0.1.0
+Summary: A command-line interface for exploring breweries via the Open Brewery DB API.
+Project-URL: Homepage, https://github.com/tynardone/brewcli
+Project-URL: Repository, https://github.com/tynardone/brewcli
+Author-email: Tyler Nardone <tynardone@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: beer,brewery,cli,openbrewerydb
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Utilities
+Requires-Python: >=3.12
+Requires-Dist: click>=8.1.8
+Requires-Dist: httpx>=0.28.1
+Description-Content-Type: text/markdown
+
+# brewcli
+
+> A command-line interface (CLI) for exploring breweries via the [Open Brewery DB API](https://www.openbrewerydb.org/).
+
+![Code Style: Ruff][ruff-style]
+![Type Checked: Mypy][mypy-check]
+![Python Versions][python-versions]
+![License][license]
+![Downloads][downloads]
+
+`brewcli` is a Python-based CLI tool designed to interact with the [Open Brewery DB API](https://www.openbrewerydb.org/). With `brewcli`, you can fetch random breweries, search breweries by city, state, or type, and more—all from the command line.
+
+## Features
+
+- Fetch a list of random breweries.
+- Search breweries by city, country, name, postal code, state, type, or distance from a coordinate.
+- Retrieve detailed information about a specific brewery by its ID.
+- Output data in a user-friendly format.
+
+## Installation
+
+Install `brewcli` using pip:
+
+```sh
+pip install brewcli
+```
+
+## Usage example
+
+Here are some examples of how to use brewcli:
+
+Get a number of random breweries (the count is required):
+
+```sh
+brewcli random 5
+```
+
+Look up a specific brewery by its ID:
+
+```sh
+brewcli by-id b54b16e1-ac3b-4bff-a11f-f7ae9ddc27e0
+```
+
+Search breweries by city:
+
+```sh
+brewcli search --by-city "Cincinnati"
+```
+
+Search breweries by state and type:
+
+```sh
+brewcli search --by-state "California" --by-type "micro"
+```
+
+Available `search` filters: `--by-city`, `--by-country`, `--by-dist` (coordinates as
+`'lat,lon'`), `--by-name`, `--by-postal`, `--by-state`, and `--by-type` (one of:
+`micro`, `nano`, `regional`, `brewpub`, `planning`, `contract`, `proprietor`, `closed`).
+
+Run `brewcli --help` or `brewcli <command> --help` for full usage details.
+
+## Development setup
+
+This project uses [uv](https://docs.astral.sh/uv/) for dependency management and is
+pinned to Python 3.12 (see `.python-version`).
+
+Clone the repository:
+
+```sh
+git clone https://github.com/tynardone/brewcli.git
+cd brewcli
+```
+
+Create the virtual environment and install all dependencies (runtime + dev) from the
+lockfile:
+
+```sh
+uv sync
+```
+
+Run the CLI:
+
+```sh
+uv run brewcli --help
+```
+
+Run tests:
+
+```sh
+uv run pytest
+```
+
+## Release History
+
+- 0.1.0
+  - Work in progress
+
+## Meta
+
+Tyler Nardone – <tynardone@gmail.com> - [LinkedIn](https://www.linkedin.com/in/tynardone/)
+
+Distributed under the MIT license. See ``LICENSE`` for more information.
+
+[https://github.com/tynardone/brewcli](https://github.com/tynardone/brewcli)
+
+<!-- Markdown link & img dfn's -->
+[python-versions]: https://img.shields.io/pypi/pyversions/brewcli
+[license]: https://img.shields.io/github/license/tynardone/brewcli
+[downloads]: https://img.shields.io/pypi/dm/brewcli
+[ruff-style]:https://img.shields.io/badge/code%20style-ruff-000000?style=flat&logo=python
+[mypy-check]:https://img.shields.io/badge/type%20checked-mypy-blue?style=flat&logo=python

brewcli-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+brewcli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+brewcli/__main__.py,sha256=8hDtWlaFZK24KhfNq_ZKgtXqYHsDQDetukOCMlsbW0Q,59
+brewcli/brewery.py,sha256=UxVH4KVXl_8y_DuvRcVfkHwi13rwIA1Isr9KHrOiH4o,3923
+brewcli/cli.py,sha256=tKfQ_StGOrNmyeMXnD0wl0on1B6B96DOUS3TgKikrz0,3504
+brewcli/logging.py,sha256=WVyfrUFb76KLNicpLCA4qkcaZs3iio0SAIcCiBoddSA,475
+brewcli/logging_config.json,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+brewcli/models.py,sha256=EtWPo7kntpO8o73us2VN2ut8EHAkq4SwHqa2HOc2HZ8,13925
+brewcli/utils.py,sha256=cskac6dy_UMQ1y6iQVaikNI2C-gqBEXu3Sk7h4zSScw,112
+brewcli-0.1.0.dist-info/METADATA,sha256=1-V1DIahy837hWbbk5j8SFUpaKyV53X2guO7pbKVtL8,3566
+brewcli-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+brewcli-0.1.0.dist-info/entry_points.txt,sha256=OI8MmuKfm_uGiK85alZJs7VppTNNIpTNf_lqKDUAbOY,44
+brewcli-0.1.0.dist-info/licenses/LICENSE,sha256=cTJ4K4Xjoc3FPoYKGyhI0HwBtf-ZaKi9noJ4DJIR3kk,1072
+brewcli-0.1.0.dist-info/RECORD,,

brewcli-0.1.0.dist-info/WHEEL

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

brewcli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+brewcli = brewcli.cli:cli

brewcli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2025 Tyler Nardone
+
+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.