Metadata-Version: 2.4
Name: lastlight
Version: 0.1.2
Summary: Low-power, offline retrieval for disaster and infrastructure-failure guidance.
Author: Eduardo J. Barrios
License: Mozilla Public License Version 2.0
        ==================================
        
        1. Definitions
        --------------
        
        1.1. "Contributor" means each individual or legal entity that creates,
        contributes to the creation of, or owns Covered Software.
        
        1.2. "Contributor Version" means the combination of the Contributions of
        others, if any, used by a Contributor and that particular Contributor's
        Contribution.
        
        1.3. "Contribution" means Covered Software of a particular Contributor.
        
        1.4. "Covered Software" means Source Code Form to which the initial Contributor
        has attached the notice in Exhibit A, the Executable Form of such Source Code
        Form, and Modifications of such Source Code Form, in each case including
        portions thereof.
        
        1.5. "Incompatible With Secondary Licenses" means that the initial Contributor
        has attached the notice described in Exhibit B to the Covered Software; or that
        the Covered Software was made available under the terms of version 1.1 or
        earlier of the License, but not also under the terms of a Secondary License.
        
        1.6. "Executable Form" means any form of the work other than Source Code Form.
        
        1.7. "Larger Work" means a work that combines Covered Software with other
        material, in a separate file or files, that is not Covered Software.
        
        1.8. "License" means this document.
        
        1.9. "Licensable" means having the right to grant, to the maximum extent
        possible, whether at the time of the initial grant or subsequently, any and all
        of the rights conveyed by this License.
        
        1.10. "Modifications" means any of the following:
        
        (a) any file in Source Code Form that results from an addition to, deletion
        from, or modification of the contents of Covered Software; or
        
        (b) any new file in Source Code Form that contains any Covered Software.
        
        1.11. "Patent Claims" of a Contributor means any patent claim(s), including
        without limitation, method, process, and apparatus claims, in any patent
        Licensable by such Contributor that would be infringed, but for the grant of
        the License, by the making, using, selling, offering for sale, having made,
        import, or transfer of either its Contributions or its Contributor Version.
        
        1.12. "Secondary License" means either the GNU General Public License, Version
        2.0, the GNU Lesser General Public License, Version 2.1, the GNU Affero General
        Public License, Version 3.0, or any later versions of those licenses.
        
        1.13. "Source Code Form" means the form of the work preferred for making
        modifications.
        
        1.14. "You" means an individual or a legal entity exercising rights under this
        License.
        
        2. License Grants and Conditions
        --------------------------------
        
        2.1. Grants
        
        Each Contributor hereby grants You a world-wide, royalty-free, non-exclusive
        license:
        
        (a) under intellectual property rights other than patent or trademark
        Licensable by such Contributor to use, reproduce, make available, modify,
        display, perform, distribute, and otherwise exploit its Contributions, either
        on an unmodified basis, with Modifications, or as part of a Larger Work; and
        
        (b) under Patent Claims of such Contributor to make, use, sell, offer for sale,
        have made, import, and otherwise transfer either its Contributions or its
        Contributor Version.
        
        2.2. Effective Date
        
        The licenses granted in Section 2.1 with respect to any Contribution become
        effective for each Contribution on the date the Contributor first distributes
        such Contribution.
        
        2.3. Limitations on Grant Scope
        
        The licenses granted in this Section 2 are the only rights granted under this
        License. No additional rights or licenses will be implied from the distribution
        or licensing of Covered Software under this License. Notwithstanding Section
        2.1(b) above, no patent license is granted by a Contributor:
        
        (a) for any code that a Contributor has removed from Covered Software; or
        
        (b) for infringements caused by: (i) Your and any other third party's
        modifications of Covered Software, or (ii) the combination of its Contributions
        with other software except as part of its Contributor Version; or
        
        (c) under Patent Claims infringed by Covered Software in the absence of its
        Contributions.
        
        This License does not grant any rights in the trademarks, service marks, or
        logos of any Contributor except as necessary to comply with Section 3.4.
        
        2.4. Subsequent Licenses
        
        No Contributor makes additional grants as a result of Your choice to distribute
        the Covered Software under a subsequent version of this License.
        
        2.5. Representation
        
        Each Contributor represents that the Contributor believes its Contributions are
        its original creation(s) or it has sufficient rights to grant the rights to its
        Contributions conveyed by this License.
        
        2.6. Fair Use
        
        This License is not intended to limit any rights You have under applicable
        copyright doctrines of fair use, fair dealing, or other equivalents.
        
        2.7. Conditions
        
        Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in
        Section 2.1.
        
        3. Responsibilities
        -------------------
        
        3.1. Distribution of Source Form
        
        All distribution of Covered Software in Source Code Form, including any
        Modifications that You create or to which You contribute, must be under the
        terms of this License. You must inform recipients that the Source Code Form of
        the Covered Software is governed by the terms of this License, and how they can
        obtain a copy of this License. You may not attempt to alter or restrict the
        recipients' rights in the Source Code Form.
        
        3.2. Distribution of Executable Form
        
        If You distribute Covered Software in Executable Form then:
        
        (a) such Covered Software must also be made available in Source Code Form, as
        described in Section 3.1, and You must inform recipients how they can obtain a
        copy of such Source Code Form by reasonable means in a timely manner, at a
        charge no more than the cost of distribution to the recipient; and
        
        (b) You may distribute such Executable Form under the terms of this License, or
        sub-license it under different terms, provided that the license for the
        Executable Form does not attempt to limit or alter the recipients' rights in the
        Source Code Form under this License.
        
        3.3. Distribution of a Larger Work
        
        You may create and distribute a Larger Work under terms of Your choice,
        provided that You also comply with the requirements of this License for the
        Covered Software. If the Larger Work is a combination of Covered Software with
        a work governed by one or more Secondary Licenses, and the Covered Software is
        not Incompatible With Secondary Licenses, this License permits You to
        additionally distribute such Covered Software under the terms of such Secondary
        License(s), so that the recipient of the Larger Work may, at their option,
        further distribute the Covered Software under the terms of either this License
        or such Secondary License(s).
        
        3.4. Notices
        
        You may not remove or alter the substance of any license notices contained
        within the Source Code Form of the Covered Software, except that You may alter
        any license notices to the extent required to remedy known factual inaccuracies.
        
        3.5. Application of Additional Terms
        
        You may choose to offer, and to charge a fee for, warranty, support, indemnity
        or liability obligations to one or more recipients of Covered Software.
        However, You may do so only on Your own behalf, and not on behalf of any
        Contributor. You must make it absolutely clear that any such warranty, support,
        indemnity, or liability obligation is offered by You alone, and You hereby
        agree to indemnify every Contributor for any liability incurred by such
        Contributor as a result of warranty, support, indemnity or liability terms You
        offer. You may include additional disclaimers of warranty and limitations of
        liability specific to any jurisdiction.
        
        4. Inability to Comply Due to Statute or Regulation
        ---------------------------------------------------
        
        If it is impossible for You to comply with any of the terms of this License
        with respect to some or all of the Covered Software due to statute, judicial
        order, or regulation then You must comply with the terms of this License to the
        maximum extent possible.
        
        5. Termination
        --------------
        
        5.1. The rights granted under this License will terminate automatically if You
        fail to comply with any of its terms. However, if You become compliant, then
        the rights granted under this License from a particular Contributor are
        reinstated (a) provisionally, unless and until such Contributor explicitly and
        finally terminates Your grants, and (b) on an ongoing basis, if such
        Contributor fails to notify You of the non-compliance by some reasonable means
        prior to 60 days after You have come back into compliance. Moreover, Your
        grants from a particular Contributor are reinstated on an ongoing basis if such
        Contributor notifies You of the non-compliance by some reasonable means, this
        is the first time You have received notice of non-compliance with this License
        from such Contributor, and You become compliant prior to 30 days after Your
        receipt of the notice.
        
        5.2. If You initiate litigation against any entity by asserting a patent
        infringement claim alleging that a Contributor Version directly or indirectly
        infringes any patent, then the rights granted to You by any and all
        Contributors for the Covered Software under Section 2.1 of this License shall
        terminate.
        
        5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user
        license agreements (excluding distributors and resellers) which have been
        validly granted by You or Your distributors under this License prior to
        termination shall survive termination.
        
        6. Disclaimer of Warranty
        -------------------------
        
        Covered Software is provided under this License on an "as is" basis, without
        warranty of any kind, either expressed, implied, or statutory, including,
        without limitation, warranties that the Covered Software is free of defects,
        merchantable, fit for a particular purpose or non-infringing. The entire risk
        as to the quality and performance of the Covered Software is with You. Should
        any Covered Software prove defective in any respect, You assume the cost of any
        necessary servicing, repair, or correction. This disclaimer of warranty
        constitutes an essential part of this License. No use of any Covered Software
        is authorized under this License except under this disclaimer.
        
        7. Limitation of Liability
        --------------------------
        
        Under no circumstances and under no legal theory, whether tort (including
        negligence), contract, or otherwise, shall any Contributor, or anyone who
        distributes Covered Software as permitted above, be liable to You for any
        direct, indirect, special, incidental, or consequential damages of any character
        including, without limitation, damages for lost profits, loss of goodwill, work
        stoppage, computer failure or malfunction, or any and all other commercial
        damages or losses, even if such party shall have been informed of the
        possibility of such damages. This limitation of liability shall not apply to
        liability for death or personal injury resulting from such party's negligence
        to the extent applicable law prohibits such limitation. Some jurisdictions do
        not allow the exclusion or limitation of incidental or consequential damages,
        so this exclusion and limitation may not apply to You.
        
        8. Litigation
        -------------
        
        Any litigation relating to this License may be brought only in the courts of a
        jurisdiction where the defendant maintains its principal place of business and
        such litigation shall be governed by laws of that jurisdiction, without
        reference to its conflict-of-law provisions. Nothing in this Section shall
        prevent a party's ability to bring cross-claims or counter-claims.
        
        9. Miscellaneous
        ----------------
        
        This License represents the complete agreement concerning the subject matter
        hereof. If any provision of this License is held to be unenforceable, such
        provision shall be reformed only to the extent necessary to make it
        enforceable. Any law or regulation which provides that the language of a
        contract shall be construed against the drafter shall not be used to construe
        this License against a Contributor.
        
        10. Versions of the License
        ---------------------------
        
        10.1. New Versions
        
        Mozilla Foundation is the license steward. Except as provided in Section 10.3,
        no one other than the license steward has the right to modify or publish new
        versions of this License. Each version will be given a distinguishing version
        number.
        
        10.2. Effect of New Versions
        
        You may distribute the Covered Software under the terms of the version of the
        License under which You originally received the Covered Software, or under the
        terms of any subsequent version published by the license steward.
        
        10.3. Modified Versions
        
        If you create software not governed by this License, and you want to create a
        new license for such software, you may create and use a modified version of
        this License if you rename the license and remove any references to the name of
        the license steward, except to note that such modified license differs from
        this License.
        
        10.4. Distributing Source Code Form that is Incompatible With Secondary
        Licenses
        
        If You choose to distribute Source Code Form that is Incompatible With
        Secondary Licenses under the terms of this version of the License, the notice
        described in Exhibit B of this License must be attached.
        
        Exhibit A - Source Code Form License Notice
        -------------------------------------------
        
        This Source Code Form is subject to the terms of the Mozilla Public License,
        v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain
        one at https://mozilla.org/MPL/2.0/.
        
        Exhibit B - "Incompatible With Secondary Licenses" Notice
        --------------------------------------------------------
        
        This Source Code Form is "Incompatible With Secondary Licenses", as defined by
        the Mozilla Public License, v. 2.0.
        
        
Project-URL: Homepage, https://github.com/edujbarrios/lastlight
Project-URL: Documentation, https://github.com/edujbarrios/lastlight/blob/main/docs/python_api.md
Project-URL: Repository, https://github.com/edujbarrios/lastlight
Project-URL: Issues, https://github.com/edujbarrios/lastlight/issues
Keywords: offline,retrieval,rag,emergency-preparedness,low-power
Classifier: Development Status :: 3 - Alpha
Classifier: Environment :: Console
Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Typing :: Typed
Classifier: Topic :: Scientific/Engineering :: Information Analysis
Requires-Python: >=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
License-File: NOTICE
Dynamic: license-file

# LastLight

[![PyPI version](https://img.shields.io/pypi/v/lastlight.svg)](https://pypi.org/project/lastlight/)
[![Python versions](https://img.shields.io/pypi/pyversions/lastlight.svg)](https://pypi.org/project/lastlight/)

**A stdlib-only Python library for low-power, offline retrieval in disaster and infrastructure-failure scenarios.**

Most modern AI systems assume that connectivity, cloud compute, large models and abundant power are available. LastLight explores the reverse case: **how much useful, auditable assistance can remain available when the infrastructure itself is unreliable?**

LastLight retrieves practical knowledge from local Markdown/ZIP packs, exposes source passages and ranking metadata, adapts retrieval strategy to resource policy, and refuses when the available evidence is too weak to support an answer.

No cloud API. No embeddings. No vector database. No telemetry. No runtime dependencies outside the Python standard library.

## Install

LastLight is published on [PyPI](https://pypi.org/project/lastlight/):

```bash
python -m pip install lastlight
```

Python 3.10+ is supported.

For development from a checkout:

```bash
python -m pip install -e .
```

## Try it in 30 seconds

Download the small demo knowledge pack used by the examples:

```bash
curl -L \
  https://raw.githubusercontent.com/edujbarrios/lastlight/main/examplepack/lastlight-example-en.zip \
  -o lastlight-example-en.zip
```

Then use LastLight as a normal Python library:

```python
from lastlight import LastLight

query = (
    "Someone has a deep cut and is bleeding heavily. "
    "What should I do while waiting for emergency services?"
)

engine = LastLight(
    "lastlight-example-en.zip",
    strategy="lexical",
)

result = engine.query(query)

print(result.accepted)
print(result.confidence)
print(result.sources[0].title)
print(f"{result.sources[0].score:.3f}")
print(result.passage)
```

Observed output:

```text
True
HIGH
Severe external bleeding
2.748
For life-threatening external bleeding, call emergency services as soon as possible. Apply firm, continuous direct pressure to the wound with a dressing or clean material.
```

The source object remains available for attribution and inspection:

```python
source = result.sources[0]

print(source.path)
print(source.language)
print(source.tags)
print(source.matched_terms)
```

```text
lastlight-example-en.zip:en/first-aid/severe-bleeding.md
en
('first-aid', 'bleeding', 'hemorrhage')
('bleeding', 'emergency', 'services', 'waiting')
```

Once the package and knowledge pack are local, querying does not require a network connection.

## Confidence-aware refusal

LastLight does not turn every weak match into an answer. The public result makes that decision explicit:

```python
from lastlight import LastLight

engine = LastLight("lastlight-example-en.zip")

result = engine.query(
    "How do I repair a diesel engine that will not start?"
)

print(result.accepted)
print(result.confidence)
print(result.passage)
```

```text
False
None
None
```

A refused query may still contain LOW-confidence retrieval candidates in `result.sources`; callers should use `result.accepted` as the answer boundary.

## Public Python API

The library is designed around a small public surface:

```python
from lastlight import (
    LastLight,
    QueryResult,
    RetrievalMetadata,
    SourceResult,
)
```

The main operations are:

```python
engine.query(text)   # structured QueryResult
engine.search(text)  # ranked retrieval results
engine.answer(text)  # formatted text response
engine.plan(text)    # adaptive retrieval plan
```

`QueryResult`, `SourceResult`, and `RetrievalMetadata` are the stable contracts intended for UIs, benchmarks and other companion repositories. See [Python API](docs/python_api.md).

## Compare retrieval strategies

LastLight exposes two fixed retrieval strategies plus an adaptive planner. The examples below are verified against the built wheel in CI so the README stays tied to the packaged library rather than only to the source tree.

This query has an immediately useful answer and is also useful for comparing ranking behavior:

```python
from lastlight import LastLight

query = (
    "The power has been out for several hours. "
    "How long will food stay safe in my refrigerator if I keep the door closed?"
)
```

### Lexical vs BM25

```python
for strategy in ("lexical", "bm25"):
    result = LastLight(
        "lastlight-example-en.zip",
        strategy=strategy,
    ).query(query)

    source = result.sources[0]
    print(
        strategy,
        source.title,
        f"score={source.score:.3f}",
        source.confidence,
    )
    print(result.passage)
```

Observed output:

```text
lexical Food safety during a power outage score=4.918 HIGH
Keep refrigerator and freezer doors closed as much as possible. As a reference, an unopened refrigerator keeps food cold for about 4 hours.

bm25 Food safety during a power outage score=11.475 HIGH
Keep refrigerator and freezer doors closed as much as possible. As a reference, an unopened refrigerator keeps food cold for about 4 hours.
```

The numeric score scales are strategy-specific, so `4.918` and `11.475` should **not** be compared directly. What matters is ranking and confidence within each retrieval strategy.

### Adaptive strategy selection

Adaptive mode does not blend lexical and BM25 scores. It deterministically chooses a retrieval strategy from query risk, operating mode and resource policy.

```python
for mode in ("survival", "balanced", "accuracy"):
    plan = LastLight(
        "lastlight-example-en.zip",
        strategy="adaptive",
        mode=mode,
    ).plan(query)

    print(
        mode,
        plan.strategy,
        plan.effective_top_k,
        plan.risk,
        plan.reason,
    )
```

Observed decisions:

```text
survival lexical 2 normal survival mode caps retrieval cost
balanced bm25 3 normal balanced mode with sufficient detected resources
accuracy bm25 3 normal accuracy mode with no active resource constraint
```

The same query therefore demonstrates the trade-off clearly: `survival` caps retrieval cost with lexical search, while `balanced` and `accuracy` can choose BM25 when resources allow it.

Explicit resource budgets can change the plan:

```python
plan = LastLight(
    "lastlight-example-en.zip",
    strategy="adaptive",
    mode="balanced",
    energy_budget_mwh=0.4,
).plan(query)

print(plan.strategy)
print(plan.effective_top_k)
print(plan.reason)
```

```text
lexical
2
energy budget is at or below 0.5 mWh/query
```

See [Adaptive Retrieval](docs/adaptive_retrieval.md) for the complete decision order and policy thresholds.

## Use multiple knowledge packs

Packs remain independently versioned and distributable, while the library can search several as one local corpus:

```python
from lastlight import LastLight

engine = LastLight.from_packs(
    [
        "packs/water-en.zip",
        "packs/first-aid-en.zip",
        "packs/blackout-en.zip",
    ],
    strategy="adaptive",
    mode="balanced",
)

result = engine.query(
    "Someone is bleeding heavily and the power is out. "
    "What guidance is available?"
)

for source in result.sources:
    print(source.path, source.confidence, source.score)
```

This is the intended integration point for projects such as `lastlight-ui` or `lastlight-bench`: they import the library instead of spawning and parsing the CLI.

## Knowledge packs

LastLight does not ship a fixed emergency corpus. Runtime knowledge is external and can be distributed separately from the Python package.

A typical pack looks like:

```text
water-en.zip
├── lastlight-pack.json
├── en/
│   └── water/
│       ├── purification.md
│       └── storage.md
└── sources/
    └── references.json
```

[`knowledge/README.md`](knowledge/README.md) documents the pack format. See also [Knowledge Packs](docs/knowledge_packs.md) and [Knowledge Pack Provenance](docs/pack_provenance.md).

## Language behavior

Language selection is also available from the library:

```python
engine = LastLight(
    "pack.zip",
    language="es",
)
```

An explicit language always wins. Without one, LastLight adopts a monolingual corpus language automatically and conservatively routes clear Spanish/English queries inside mixed corpora. Retrieved passages remain in their original language; LastLight does not silently translate them.

## CLI utilities

The CLI remains a first-party interface, but it is secondary to the Python API. Installing from PyPI also installs the `lastlight` command.

Useful operational commands include:

```bash
lastlight --help
lastlight --knowledge pack.zip --validate-pack
lastlight --knowledge pack.zip --verify-provenance
lastlight --knowledge pack.zip --format sources "How can I make this water safer?"
```

The CLI and the Python API use the same runtime implementation.

## Development and verification

From a checkout:

```bash
git clone https://github.com/edujbarrios/lastlight.git
cd lastlight
python -m pip install -e .
python tools/check_core.py
```

CI verifies Python 3.10 and 3.12, builds wheel and source distributions, installs the built wheel in an isolated environment, and executes the library examples for lexical retrieval, BM25 retrieval, adaptive planning and refusal behavior.

## Research direction

LastLight treats offline intelligence as a systems problem rather than a model-size competition:

> How much useful, trustworthy assistance can be preserved per unit of compute, memory, energy and stored knowledge when external infrastructure is unavailable?

The project is intended to make that trade-off measurable and auditable rather than hiding it behind a remote service.

## Ecosystem direction

The runtime is library-first so companion projects can depend on a stable Python API:

```text
lastlight-ui ──────► lastlight
lastlight-bench ───► lastlight
other integrations ► lastlight
```

Knowledge packs, pack-authoring tools and a future catalog can evolve independently around the same pack contract. See [Ecosystem](ECOSYSTEM.md).

## Docs

- [Python API](docs/python_api.md)
- [Architecture](docs/architecture.md)
- [Knowledge Packs](docs/knowledge_packs.md)
- [Knowledge Pack Provenance](docs/pack_provenance.md)
- [Adaptive Retrieval](docs/adaptive_retrieval.md)
- [Ecosystem](ECOSYSTEM.md)

## License

Mozilla Public License 2.0.
