semvec/pypi-packages huggingface dataset:
news-summizr 2025.12.21232733
news-summizr extracts structured summaries from headlines, labeling key points like announcement, products, region for quick insight.
License: MIT
Requires Python: >=3.9

# news_summizr
[![PyPI version](https://badge.fury.io/py/news-summizr.svg)](https://badge.fury.io/py/news-summizr)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
[![Downloads](https://static.pepy.tech/badge/news-summizr)](https://pepy.tech/project/news-summizr)
[![LinkedIn](https://img.shields.io/badge/LinkedIn-blue)](https://www.linkedin.com/in/eugene-evstafev-716669181/)

Simplify extracting structured summaries from news articles with this package.

## Overview
A new package designed to simplify extracting structured summaries from news articles. It takes a headline or brief input about recent events and generates a concise, labeled summary emphasizing key points such as the main announcement, affected products, and regional focus.

## Installation
```bash
pip install news_summizr
```

## Usage
```python
from news_summizr import news_summizr

response = news_summizr(user_input="Some news article headline", llm=None, api_key=None)
```
Input parameters:

* `user_input`: str - the user input text to process
* `llm`: Optional[BaseChatModel] - the langchain llm instance to use, if not provided the default ChatLLM7 will be used.
* `api_key`: Optional[str] - the api key for llm7, if not provided.

By default, it uses the ChatLLM7 from langchain_llm7: https://pypi.org/project/langchain-llm7/.

You can safely pass your own llm instance (based on https://docs.langchain.com/) if you want to use another LLM, via passing it like `news_summizr(user_input, llm=your_llm_instance)`.

Here are some examples of other LLMs you can use:

```python
from langchain_openai import ChatOpenAI
from news_summizr import news_summizr

llm = ChatOpenAI()
response = news_summizr(user_input, llm=llm)

from langchain_anthropic import ChatAnthropic
from news_summizr import news_summizr

llm = ChatAnthropic()
response = news_summizr(user_input, llm=llm)

from langchain_google_genai import ChatGoogleGenerativeAI
from news_summizr import news_summizr

llm = ChatGoogleGenerativeAI()
response = news_summizr(user_input, llm=llm)
```

The default rate limits for LLM7 free tier are sufficient for most use cases of this package. If you want higher rate limits for LLM7, you can pass your own api key via environment variable `LLM7_API_KEY` or via passing it directly like `news_summizr(user_input, api_key="your_api_key")`. You can get a free api key by registering at https://token.llm7.io/.

## GitHub Issues
https://github.com/chigwell/news-summizr

## Author

Eugene Evstafev
hi@euegne.plus
finclaimvalid 2025.12.21230358
Verify financial claims with rapid analysis and data-driven insights
License: MIT
Requires Python: >=3.9

# finclaimvalid
[![PyPI version](https://badge.fury.io/py/finclaimvalid.svg)](https://badge.fury.io/py/finclaimvalid)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
[![Downloads](https://static.pepy.tech/badge/finclaimvalid)](https://pepy.tech/project/finclaimvalid)
[![LinkedIn](https://img.shields.io/badge/LinkedIn-blue)](https://www.linkedin.com/in/eugene-evstafev-716669181/)


finclaimvalid is a Python package that helps you assess the validity of financial or investment claims through natural language analysis. It interprets user queries and provides structured, concise responses based on historical data patterns. This tool is especially useful for financial advisors, educational platforms, or individual investors seeking quick, reliable insights without manual data searches.

## Installation

Install the package via pip:

```bash
pip install finclaimvalid
```

## Usage Example

Here's a basic example demonstrating how to use finclaimvalid with your own language model:

```python
from finclaimvalid import finclaimvalid

# Using the default LLM7 model
response = finclaimvalid(user_input="Is the recent claim about stock growth valid?")

# Using a custom language model, e.g., OpenAI's ChatOpenAI
from langchain_openai import ChatOpenAI

llm = ChatOpenAI()
response = finclaimvalid(user_input="Is the recent claim about stock growth valid?", llm=llm)
```

### Parameters

- **user_input** *(str)*: The text query about the financial claim.
- **llm** *(Optional[BaseChatModel])*: An optional language model instance from langchain. If not provided, the default ChatLLM7 will be used.
- **api_key** *(Optional[str])*: Your API key for LLM7 services. If not provided, the package will look for the environment variable `LLM7_API_KEY`. You can obtain a free key at [https://token.llm7.io/](https://token.llm7.io/).

### Supported Language Models

- **ChatLLM7** (default), from `langchain_llm7`

You can also pass other models, such as:

```python
from langchain_anthropic import ChatAnthropic
from finclaimvalid import finclaimvalid

llm = ChatAnthropic()
response = finclaimvalid(user_input="Check the validity of this claim.", llm=llm)
```

## Notes

- The package adapts to various LLMs by accepting any compatible language model instance.
- Rate limits typically match the free tier of LLM7 but can be increased by applying for a higher quota using your API key.
- Your API key can be set via environment variable or directly passed as an argument.

## License

This project is licensed under the MIT License.

## Support

For issues or feature requests, please visit the GitHub issues page:  
[https://github.com/.../issues](https://github.com/.../issues)

## Author

- **Eugene Evstafev**  
  Email: hi@eugene.plus  
  GitHub: [@chigwell](https://github.com/chigwell)
intentpy 0.1.0
Declarative intent-based execution with preconditions, fallbacks, and nested intent tracing
License: MIT
Requires Python: >=3.8
Keywords: intent, control-flow, workflow, architecture, reliability

# intentpy

**intentpy** is a lightweight Python library for **intent-based execution** —
where *what you want to do* is declared separately from *whether it is allowed to happen*.

It provides:
- Declarative **preconditions**
- Explicit **fallback policies**
- **Nested intent execution**
- Structured, readable runtime traces

This is **not** a circuit breaker or workflow engine.
It is a semantic execution layer.

---

## Why intentpy?

Traditional decorators answer:
> “Should this function run?”

Intent-based execution answers:
> “What is the intent, what does it require, and what happens if it fails?”

This makes complex logic:
- composable
- debuggable
- intention-revealing

---

## Core Concepts

### Intent
An intent represents a meaningful action:
- it has **requirements**
- it produces **effects**
- it may **fail gracefully**

### Condition
Reusable boolean predicates that gate execution.

### Fallback
Named handlers that execute when an intent cannot proceed.

### Nesting
Intents can call other intents.
Execution is tracked as a runtime tree.

---

## Example: Nested Intent Execution

```python
from intentpy import intent, condition, fallback, ExecutionContext


class User:
    def __init__(self, authenticated: bool):
        self.is_authenticated = authenticated


@condition("user_authenticated")
def is_authenticated(ctx):
    return ctx.user.is_authenticated


@fallback("log_only")
def log_only(ctx, intent):
    print(f"Handled failure for intent: {intent.name}")


@intent(
    name="send_email",
    requires=["user_authenticated"],
    effects=["email_sent"],
    on_fail="log_only"
)
def send_email(ctx):
    print("Sending email...")


@intent(
    name="process_order",
    requires=["user_authenticated"],
    effects=["order_processed"],
    on_fail="log_only"
)
def process_order(ctx):
    send_email(ctx=ctx)


ctx = ExecutionContext(user=User(authenticated=True))
process_order(ctx=ctx)