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

starbash/repo/manager.py

@@ -5,20 +5,24 @@ Manages the repository of processing recipes and configurations.
 from __future__ import annotations
 import logging
 from pathlib import Path
+from importlib import resources
 
 import tomlkit
+from tomlkit.toml_file import TOMLFile
 from tomlkit.items import AoT
 from multidict import MultiDict
 
 
 repo_suffix = "starbash.toml"
 
+REPO_REF = "repo-ref"
+
 
 class Repo:
     """
     Represents a single starbash repository."""
 
-    def __init__(self, manager: RepoManager, url: str, config: str | None = None):
+    def __init__(self, manager: RepoManager, url: str):
         """
         Initializes a Repo instance.
 
@@ -27,15 +31,14 @@ class Repo:
         """
         self.manager = manager
         self.url = url
-        self.config = tomlkit.parse(config) if config else self._load_config()
-        self.manager.add_all_repos(self.config, self.get_path())
+        self.config = self._load_config()
 
     def __str__(self) -> str:
         """Return a concise one-line description of this repo.
 
         Example: "Repo(kind=recipe, local=True, url=file:///path/to/repo)"
         """
-        return f"Repo(kind={self.kind}, local={self.is_local}, url={self.url})"
+        return f"Repo(kind={self.kind}, url={self.url})"
 
     __repr__ = __str__
 
@@ -49,8 +52,37 @@ class Repo:
         """
         return str(self.get("repo.kind", "unknown"))
 
-    @property
-    def is_local(self) -> bool:
+    def add_repo_ref(self, dir: str) -> None:
+        aot = self.config.get(REPO_REF, None)
+        if aot is None:
+            aot = tomlkit.aot()
+        else:
+            self.config.remove(
+                REPO_REF
+            )  # We want to completely replace it at the end of the file
+
+        ref = {"dir": dir}
+        aot.append(ref)
+        self.config[REPO_REF] = aot
+        self.add_from_ref(ref)
+
+    def write_config(self) -> None:
+        """
+        Writes the current (possibly modified) configuration back to the repository's config file.
+
+        Raises:
+            ValueError: If the repository is not a local file repository.
+        """
+        base_path = self.get_path()
+        if base_path is None:
+            raise ValueError("Cannot resolve path for non-local repository")
+
+        config_path = base_path / repo_suffix
+        # FIXME, be more careful to write the file atomically (by writing to a temp file and renaming)
+        TOMLFile(config_path).write(self.config)
+        logging.debug(f"Wrote config to {config_path}")
+
+    def is_scheme(self, scheme: str = "file") -> bool:
         """
         Read-only attribute indicating whether the repository URL points to a
         local file system path (file:// scheme).
@@ -58,7 +90,7 @@ class Repo:
         Returns:
             bool: True if the URL is a local file path, False otherwise.
         """
-        return self.url.startswith("file://")
+        return self.url.startswith(f"{scheme}://")
 
     def get_path(self) -> Path | None:
         """
@@ -70,12 +102,39 @@ class Repo:
         Returns:
             A Path object if the URL is a local file, otherwise None.
         """
-        if self.is_local:
+        if self.is_scheme("file"):
             return Path(self.url[len("file://") :])
 
         return None
 
-    def read(self, filepath: str) -> str:
+    def add_from_ref(self, ref: dict) -> None:
+        """
+        Adds a repository based on a repo-ref dictionary.
+        """
+        if "url" in ref:
+            url = ref["url"]
+        elif "dir" in ref:
+            path = Path(ref["dir"])
+            base_path = self.get_path()
+            if base_path and not path.is_absolute():
+                # Resolve relative to the current TOML file's directory
+                path = (base_path / path).resolve()
+            else:
+                # Expand ~ and resolve from CWD
+                path = path.expanduser().resolve()
+            url = f"file://{path}"
+        else:
+            raise ValueError(f"Invalid repo reference: {ref}")
+        self.manager.add_repo(url)
+
+    def add_by_repo_refs(self) -> None:
+        """Add all repos mentioned by repo-refs in this repo's config."""
+        repo_refs = self.config.get(REPO_REF, [])
+
+        for ref in repo_refs:
+            self.add_from_ref(ref)
+
+    def _read_file(self, filepath: str) -> str:
         """
         Read a filepath relative to the base of this repo. Return the contents in a string.
 
@@ -96,7 +155,31 @@ class Repo:
 
         return target_path.read_text()
 
-    def _load_config(self) -> dict:
+    def _read_resource(self, filepath: str) -> str:
+        """
+        Read a resource from the installed starbash package using a pkg:// URL.
+
+        Assumptions (simplified per project constraints):
+        - All pkg URLs point somewhere inside the already-imported 'starbash' package.
+        - The URL is treated as a path relative to the starbash package root.
+
+        Examples:
+            url: pkg://defaults   + filepath: "starbash.toml"
+              -> reads starbash/defaults/starbash.toml
+
+        Args:
+            filepath: Path within the base resource directory for this repo.
+
+        Returns:
+            The content of the resource as a string (UTF-8).
+        """
+        # Path portion after pkg://, interpreted relative to the 'starbash' package
+        subpath = self.url[len("pkg://") :].strip("/")
+
+        res = resources.files("starbash").joinpath(subpath).joinpath(filepath)
+        return res.read_text()
+
+    def _load_config(self) -> tomlkit.TOMLDocument:
         """
         Loads the repository's configuration file (e.g., repo.sb.toml).
 
@@ -106,12 +189,19 @@ class Repo:
             A dictionary containing the parsed configuration.
         """
         try:
-            config_content = self.read(repo_suffix)
+            if self.is_scheme("file"):
+                config_content = self._read_file(repo_suffix)
+            elif self.is_scheme("pkg"):
+                config_content = self._read_resource(repo_suffix)
+            else:
+                raise ValueError(f"Unsupported URL scheme for repo: {self.url}")
             logging.debug(f"Loading repo config from {repo_suffix}")
             return tomlkit.parse(config_content)
         except FileNotFoundError:
-            logging.warning(f"No {repo_suffix} found")
-            return {}
+            logging.debug(
+                f"No {repo_suffix} found"
+            )  # we currently make it optional to have the config file at root
+            return tomlkit.TOMLDocument()  # empty placeholder
 
     def get(self, key: str, default=None):
         """
@@ -142,42 +232,31 @@ class RepoManager:
     files (like appdefaults.sb.toml).
     """
 
-    def __init__(self, app_defaults: str):
+    def __init__(self):
         """
         Initializes the RepoManager by loading the application default repos.
         """
         self.repos = []
 
         # We expose the app default preferences as a special root repo with a private URL
-        root_repo = Repo(self, "pkg://starbash-defaults", config=app_defaults)
-        self.repos.append(root_repo)
+        # root_repo = Repo(self, "pkg://starbash-defaults", config=app_defaults)
+        # self.repos.append(root_repo)
 
         # Most users will just want to read from merged
-        self.merged = self._union()
+        self.merged = MultiDict()
 
-    def add_all_repos(self, toml: dict, base_path: Path | None = None) -> None:
-        # From appdefaults.sb.toml, repo.ref is a list of tables
-        repo_refs = toml.get("repo", {}).get("ref", [])
+    def add_repo(self, url: str) -> Repo:
+        logging.debug(f"Adding repo: {url}")
+        r = Repo(self, url)
+        self.repos.append(r)
 
-        for ref in repo_refs:
-            if "url" in ref:
-                url = ref["url"]
-            elif "dir" in ref:
-                path = Path(ref["dir"])
-                if base_path and not path.is_absolute():
-                    # Resolve relative to the current TOML file's directory
-                    path = (base_path / path).resolve()
-                else:
-                    # Expand ~ and resolve from CWD
-                    path = path.expanduser().resolve()
-                url = f"file://{path}"
-            else:
-                raise ValueError(f"Invalid repo reference: {ref}")
-            self.add_repo(url)
+        # FIXME, generate the merged dict lazily
+        self._add_merged(r)
 
-    def add_repo(self, url: str) -> None:
-        logging.debug(f"Adding repo: {url}")
-        self.repos.append(Repo(self, url))
+        # if this new repo has sub-repos, add them too
+        r.add_by_repo_refs()
+
+        return r
 
     def get(self, key: str, default=None):
         """
@@ -214,32 +293,18 @@ class RepoManager:
             # For a debug dump, a simple string representation is usually sufficient.
             logging.info(f"  %s: %s", key, value)
 
-    def _union(self) -> MultiDict:
-        """
-        Merges the top-level keys from all repository configurations into a MultiDict.
-
-        This method iterates through all loaded repositories in their original order
-        and combines their top-level configuration keys. If a key exists in multiple
-        repositories, all of its values will be present in the returned MultiDict.
-
-        Returns:
-            A MultiDict containing the union of all top-level keys.
-        """
-        merged_dict = MultiDict()
-        for repo in self.repos:
-            for key, value in repo.config.items():
-                # if the toml object is an AoT type, monkey patch each element in the array instead
-                if isinstance(value, AoT):
-                    for v in value:
-                        setattr(v, "source", repo)
+    def _add_merged(self, repo: Repo) -> None:
+        for key, value in repo.config.items():
+            # if the toml object is an AoT type, monkey patch each element in the array instead
+            if isinstance(value, AoT):
+                for v in value:
+                    setattr(v, "source", repo)
                 else:
                     # We monkey patch source into any object that came from a repo, so that users can
                     # find the source repo (for attribution, URL relative resolution, whatever...)
                     setattr(value, "source", repo)
 
-                merged_dict.add(key, value)
-
-        return merged_dict
+            self.merged.add(key, value)
 
     def __str__(self):
         lines = [f"RepoManager with {len(self.repos)} repositories:"]

starbash/selection.py

@@ -0,0 +1,215 @@
+"""Selection state management for filtering sessions and targets."""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Optional
+from datetime import datetime
+
+
+class Selection:
+    """Manages the current selection state for filtering sessions and targets.
+
+    This class maintains persistent state about what the user has selected:
+    - Target names
+    - Date ranges
+    - Filters
+    - Image types
+
+    The selection state is saved to disk and can be used to build database queries.
+    """
+
+    def __init__(self, state_file: Path):
+        """Initialize the Selection with a state file path.
+
+        Args:
+            state_file: Path to the JSON file where selection state is persisted
+        """
+        self.state_file = state_file
+        self.targets: list[str] = []
+        self.date_start: Optional[str] = None
+        self.date_end: Optional[str] = None
+        self.filters: list[str] = []
+        self.image_types: list[str] = []
+
+        # Load existing state if it exists
+        self._load()
+
+    def _load(self) -> None:
+        """Load selection state from disk."""
+        if self.state_file.exists():
+            try:
+                with open(self.state_file, "r") as f:
+                    data = json.load(f)
+                    self.targets = data.get("targets", [])
+                    self.date_start = data.get("date_start")
+                    self.date_end = data.get("date_end")
+                    self.filters = data.get("filters", [])
+                    self.image_types = data.get("image_types", [])
+                logging.debug(f"Loaded selection state from {self.state_file}")
+            except Exception as e:
+                logging.warning(f"Failed to load selection state: {e}")
+
+    def _save(self) -> None:
+        """Save selection state to disk."""
+        try:
+            # Ensure parent directory exists
+            self.state_file.parent.mkdir(parents=True, exist_ok=True)
+
+            data = {
+                "targets": self.targets,
+                "date_start": self.date_start,
+                "date_end": self.date_end,
+                "filters": self.filters,
+                "image_types": self.image_types,
+            }
+
+            with open(self.state_file, "w") as f:
+                json.dump(data, f, indent=2)
+            logging.debug(f"Saved selection state to {self.state_file}")
+        except Exception as e:
+            logging.error(f"Failed to save selection state: {e}")
+
+    def clear(self) -> None:
+        """Clear all selection criteria (select everything)."""
+        self.targets = []
+        self.date_start = None
+        self.date_end = None
+        self.filters = []
+        self.image_types = []
+        self._save()
+
+    def add_target(self, target: str) -> None:
+        """Add a target to the selection.
+
+        Args:
+            target: Target name to add to the selection
+        """
+        if target not in self.targets:
+            self.targets.append(target)
+            self._save()
+
+    def remove_target(self, target: str) -> None:
+        """Remove a target from the selection.
+
+        Args:
+            target: Target name to remove from the selection
+        """
+        if target in self.targets:
+            self.targets.remove(target)
+            self._save()
+
+    def set_date_range(
+        self, start: Optional[str] = None, end: Optional[str] = None
+    ) -> None:
+        """Set the date range for the selection.
+
+        Args:
+            start: ISO format date string for start of range (inclusive)
+            end: ISO format date string for end of range (inclusive)
+        """
+        self.date_start = start
+        self.date_end = end
+        self._save()
+
+    def add_filter(self, filter_name: str) -> None:
+        """Add a filter to the selection.
+
+        Args:
+            filter_name: Filter name to add to the selection
+        """
+        if filter_name not in self.filters:
+            self.filters.append(filter_name)
+            self._save()
+
+    def remove_filter(self, filter_name: str) -> None:
+        """Remove a filter from the selection.
+
+        Args:
+            filter_name: Filter name to remove from the selection
+        """
+        if filter_name in self.filters:
+            self.filters.remove(filter_name)
+            self._save()
+
+    def is_empty(self) -> bool:
+        """Check if the selection has any criteria set.
+
+        Returns:
+            True if no selection criteria are active (selecting everything)
+        """
+        return (
+            not self.targets
+            and self.date_start is None
+            and self.date_end is None
+            and not self.filters
+            and not self.image_types
+        )
+
+    def get_query_conditions(self) -> dict[str, Any]:
+        """Build query conditions based on the current selection.
+
+        Returns:
+            Dictionary of query conditions that can be used with Database methods.
+            Special keys:
+            - 'date_start': ISO date string for start of range
+            - 'date_end': ISO date string for end of range
+        """
+        conditions = {}
+
+        # Note: This returns a simplified conditions dict.
+        # The actual query building will be enhanced later to support
+        # complex queries with date ranges, multiple targets, etc.
+
+        if self.targets:
+            # For now, just use the first target
+            # TODO: Support multiple targets in queries
+            conditions["OBJECT"] = self.targets[0] if len(self.targets) == 1 else None
+
+        if self.filters:
+            # For now, just use the first filter
+            # TODO: Support multiple filters in queries
+            conditions["FILTER"] = self.filters[0] if len(self.filters) == 1 else None
+
+        # Add date range conditions
+        if self.date_start:
+            conditions["date_start"] = self.date_start
+        if self.date_end:
+            conditions["date_end"] = self.date_end
+
+        return conditions
+
+    def summary(self) -> dict[str, Any]:
+        """Get a summary of the current selection state.
+
+        Returns:
+            Dictionary with human-readable summary of selection criteria
+        """
+        if self.is_empty():
+            return {
+                "status": "all",
+                "message": "No filters active - selecting all sessions",
+            }
+
+        summary = {"status": "filtered", "criteria": []}
+
+        if self.targets:
+            summary["criteria"].append(f"Targets: {', '.join(self.targets)}")
+
+        if self.date_start or self.date_end:
+            date_range = []
+            if self.date_start:
+                date_range.append(f"from {self.date_start}")
+            if self.date_end:
+                date_range.append(f"to {self.date_end}")
+            summary["criteria"].append(f"Date: {' '.join(date_range)}")
+
+        if self.filters:
+            summary["criteria"].append(f"Filters: {', '.join(self.filters)}")
+
+        if self.image_types:
+            summary["criteria"].append(f"Image types: {', '.join(self.image_types)}")
+
+        return summary

starbash/templates/userconfig.toml

@@ -0,0 +1,21 @@
+# This is your Starbash user configuration file.  It can be used to provide default settings
+# to workflows.
+
+# (or wherever is appropriate for the user's platform).
+
+[repo]
+kind = "preferences"
+
+[analytics]
+# enabled = true # default is true - change to false if you don't want any analytics/crash-reports
+# include_user = false # default is false - change to true if you'd like your email added to crash reports/analytics
+
+[user]
+# default author info
+# name = "Your Name"
+# email = "youremail@somedomain.com"
+# website = "https://yourwebsite"
+# license = "FIXME eventually applied as the default license for generated images Creative commons etc..."
+
+# DO NOT edit below this line, they are managed automatically via
+# the "sb repo add" etc... commands.

starbash/url.py

@@ -0,0 +1,9 @@
+project = "https://github.com/geeksville/starbash"
+analytics_docs = f"{project}/blob/main/doc/analytics.md"
+
+
+def new_issue(report_id: str | None = None) -> str:
+    if report_id:
+        return f"{project}/issues/new?body=Please%20describe%20the%20problem%2C%20but%20include%20this%3A%0ACrash%20ID%20{report_id}"
+    else:
+        return f"{project}/issues/new?body=Please%20describe%20the%20problem"

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

@@ -1,24 +1,31 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: starbash
-Version: 0.1.0
+Version: 0.1.1
 Summary: 
+License-File: LICENSE
 Author: Kevin Hester
 Author-email: kevinh@geeksville.com
 Requires-Python: >=3.12,<3.15
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: astropy (>=7.1.1,<8.0.0)
 Requires-Dist: multidict (>=6.7.0,<7.0.0)
 Requires-Dist: platformdirs (>=4.5.0,<5.0.0)
 Requires-Dist: restrictedpython (>=8.1,<9.0)
 Requires-Dist: rich (>=14.2.0,<15.0.0)
-Requires-Dist: tinydb (>=4.8.2,<5.0.0)
+Requires-Dist: sentry-sdk (>=2.42.1,<3.0.0)
 Requires-Dist: tomlkit (>=0.13.3,<0.14.0)
 Requires-Dist: typer (>=0.20.0,<0.21.0)
 Description-Content-Type: text/markdown
 
 # Starbash
-![app icon](img/icon.png "Starbash: Astrophotography workflows simplified")
+
+![PyPI - Version](https://img.shields.io/pypi/v/starbash)
+![GitHub branch check runs](https://img.shields.io/github/check-runs/geeksville/starbash/main)
+
+ ![app icon](https://github.com/geeksville/starbash/blob/main/img/icon.png "Starbash: Astrophotography workflows simplified")
 
 A tool for automating/standardizing/sharing astrophotography workflows.
 
@@ -48,20 +55,27 @@ See my personal [TODO](TODO.md) file.  I'll be looking for pre-alpha testers/fee
 * repo list
 * repo reindex REPONAME|REPONUM|all
 
-* target list
-* target select TARGETNAME
+* user analytics on|off - turn analytics collection on/off
+* user name "Your Name" - used for attribution in generated images
+* user email "foo@blah.com" - used for attribution in generated images
+
+* selection any - remove any filters on sessions, etc...
+* selection target TARGETNAME - limit the current selection to only the named targets
+* selection date op DATE - limit to sessions in the specified date range
+* selection - list information about the current selection
+
+* target - list targets (filtered based on the current selection)
 
-* reset - remove any filters on targets, sessions, etc...
+* session- list sessions (filtered based on the current selection)
 
-* session list
-* session date after DATE
-* session date before DATE
+* instrument - list instruments (filtered based on the current selection)
 
-* instrument list
+* filter - list all filters found in current selection
 
 * export dirs|BIAS|LIGHT|DARK|FLAT [DIRLOC]
 
 * process auto
+* process masters - generate master flats, darks, biases from any raws that are available
 
 ## Supported tools
 

starbash-0.1.1.dist-info/RECORD

@@ -0,0 +1,24 @@
+starbash/__init__.py,sha256=co39eIssQlFxWfO3cDhp52reRy6qEyJX5u5K8OsxiDk,138
+starbash/analytics.py,sha256=0TfiZthKRMqW38Jg1VJDjpykZXBrK33tNKuhQibkCK0,3579
+starbash/app.py,sha256=sYEgemSDZEX7yih2p_aFlrsCypWjx2zNDsNHJ_DNF0E,13319
+starbash/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+starbash/commands/repo.py,sha256=WuOg15p9LnJ6aIWIXYCKY9guRIUCq3XapyO7oi1v3hQ,1874
+starbash/commands/selection.py,sha256=4bpjYWne9ekg1EIOJS15Ymj2Hyr-jc2Te4N4mXepkpI,3941
+starbash/commands/user.py,sha256=JpwYa9cYxm2gkekcxrj7CsbJO7fgbGwRxmjvpua0BOY,1598
+starbash/database.py,sha256=jQyuZ-sFwbAIv6Wtn4VnPVQChQMP4y1rVjrEgp2iLoA,13513
+starbash/defaults/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+starbash/defaults/starbash.toml,sha256=RVfYikW5xhpZUt83U5k7O2hprswgFvDFykCWkHL37QU,2384
+starbash/main.py,sha256=7N28XCu43IUijIaTrT9ZY_aWxEmJGDdTLWdfhw_omOc,5084
+starbash/paths.py,sha256=BKKnSXt3tOh16o7ljDcQLtWKIiepEmud9JFtzRwDHtg,1317
+starbash/repo/__init__.py,sha256=TqspuLjPSNnO38tvCGa0fJvvasgecHl6fE7m0-Lj8ho,148
+starbash/repo/manager.py,sha256=XBiZXMgVKd7faddwugtWVbeR8XuJF8sZi8yAiDxT6wM,10701
+starbash/selection.py,sha256=4u4h30VeC_e8PWFdtNWA9C7AyYrcAgg3BEagSynaxMM,7111
+starbash/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+starbash/templates/userconfig.toml,sha256=NinuXl8L0xxSvI4FFZD8ye836yv8TaUP0a5VMEc-w1w,757
+starbash/tool.py,sha256=S1kOTbeHTrA0meqwftgL0SA4VhJdZWWx2h1Wtwu1Izg,8749
+starbash/url.py,sha256=lorxQJ27jSfzsKCb0QvpcvLiPZG55Dkd_c1JPFbni4I,402
+starbash-0.1.1.dist-info/METADATA,sha256=EjekS6hjvRkPf-Ka0ZUa0_XhRp50YwABIjOBlStvyH4,3539
+starbash-0.1.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+starbash-0.1.1.dist-info/entry_points.txt,sha256=REQyWs8e5TJsNK7JVVWowKVoytMmKlUwuFHLTmSX4hc,67
+starbash-0.1.1.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+starbash-0.1.1.dist-info/RECORD,,

{starbash-0.1.0.dist-info → starbash-0.1.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: true
 Tag: py3-none-any

starbash-0.1.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-starbash/__init__.py,sha256=co39eIssQlFxWfO3cDhp52reRy6qEyJX5u5K8OsxiDk,138
-starbash/app.py,sha256=8f1OSJPlgSMri8kMFrQ6nac5M1gAgPl-FRnuXeOWMAQ,8754
-starbash/appdefaults.sb.toml,sha256=YTUwTqg2DcDFs9VDB1gqchNqk-hg_cGlpaa134hLOJU,2606
-starbash/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-starbash/commands/repo.py,sha256=Xg9aaaURrv45bJF5w4rsD2X5_FdeM4dp9d9xbGaG4Ds,985
-starbash/database.py,sha256=HFJI0CAQIFfKGx3yTS7anREAcvjiNZhObwyAbD5WD48,2254
-starbash/main.py,sha256=VNV2y8pz_NMbGXjIDuFIDbbS0Q0B5GMqKTXitFf1tb4,579
-starbash/repo/__init__.py,sha256=TqspuLjPSNnO38tvCGa0fJvvasgecHl6fE7m0-Lj8ho,148
-starbash/repo/manager.py,sha256=jOhN-Rx60rtueLsHLoVdvcyWTDOqfUGZN6nbbJzRntI,8586
-starbash/tool.py,sha256=S1kOTbeHTrA0meqwftgL0SA4VhJdZWWx2h1Wtwu1Izg,8749
-starbash-0.1.0.dist-info/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-starbash-0.1.0.dist-info/METADATA,sha256=N1fSGzjmBFEWL5V7uxbwcGbS3X_UExpxja4cZjA3KIE,2564
-starbash-0.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-starbash-0.1.0.dist-info/entry_points.txt,sha256=REQyWs8e5TJsNK7JVVWowKVoytMmKlUwuFHLTmSX4hc,67
-starbash-0.1.0.dist-info/RECORD,,