semvec/pypi-packages huggingface dataset:
factofiction-analyzer 2025.12.21084430
A new package designed to help users distinguish between factual information and imaginative interpretations. This tool takes user-provided text as input and uses advanced language models to analyze a
License: MIT
Requires Python: >=3.9

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


## Overview

Factofiction Analyzer is a Python package that helps users distinguish between factual information and imaginative interpretations. It takes user-provided text as input, analyzes and structures the content using advanced language models, and identifies and separates factual statements from imaginative or speculative ones.

## Installation

```bash
pip install factofiction_analyzer
```

## Usage

Usage example:
```python
from factofiction_analyzer import factofiction_analyzer

response = factofiction_analyzer(user_input="The cat sat on the mat.")
```
Input parameters:

* `user_input`: The user input text to process (str)
* `llm`: The langchain LLM instance to use (Optional[BaseChatModel]). If not provided, the default ChatLLM7 will be used.
* `api_key`: The API key for LLM7 (Optional[str]). If not provided, the LLM7 free tier will be used.

Note: If you want to use a custom LLM instance, you can pass it as an argument like this:
```python
from langchain_openai import ChatOpenAI
from factofiction_analyzer import factofiction_analyzer

llm = ChatOpenAI()
response = factofiction_analyzer(user_input="The cat sat on the mat.", llm=llm)
```

## Supported LLMs

The package uses ChatLLM7 from langchain_llm7 by default. You can use other LLMs by passing your own instance:
* OpenAI: `langchain_openai.ChatOpenAI`
* Anthropic: `langchain_anthropic.ChatAnthropic`
* Google Generative AI: `langchain_google_genai.ChatGoogleGenerativeAI`

## API Key

If you need higher rate limits for LLM7, you can set the `LLM7_API_KEY` environment variable or pass your API key directly:
```python
factofiction_analyzer(user_input="The cat sat on the mat.", api_key="your_api_key")
```
You can obtain a free API key by registering at https://token.llm7.io/

## GitHub Issues

Report any issues or bugs to: https://github.com/your-github-nickname/factofiction-analyzer/issues

## Author

Written by Eugene Evstafev (hi@euegne.plus)

## Acknowledgement

This package uses the llmatch-messages package for consistent output formatting.
transword-matcher 2025.12.21084344
The package uses structured pattern matching to interpret user requests for language translation, extracting the source and target languages along with the text to translate. It then returns a detaile
License: MIT
Requires Python: >=3.9

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


A Python package that uses structured pattern matching to interpret user requests for language translation, extracting the source and target languages along with the text to translate. It returns a detailed, organized response including the translated text, original text, and detected source and target languages.

## Installation

```bash
pip install transword_matcher
```

## Usage

```python
from transword_matcher import transword_matcher

# Example usage with default LLM (ChatLLM7)
response = transword_matcher(
    user_input="Translate 'hello' from English to Spanish"
)
print(response)
```

### Using a Custom LLM

You can pass your own LangChain-compatible LLM instance:

```python
from langchain_openai import ChatOpenAI
from transword_matcher import transword_matcher

llm = ChatOpenAI()
response = transword_matcher(
    user_input="Translate this text to French",
    llm=llm
)
```

```python
from langchain_anthropic import ChatAnthropic
from transword_matcher import transword_matcher

llm = ChatAnthropic()
response = transword_matcher(
    user_input="How do you say 'thank you' in Japanese?",
    llm=llm
)
```

```python
from langchain_google_genai import ChatGoogleGenerativeAI
from transword_matcher import transword_matcher

llm = ChatGoogleGenerativeAI()
response = transword_matcher(
    user_input="Translate from German to English: 'Guten Tag'",
    llm=llm
)
```

### Using Custom API Key

```python
from transword_matcher import transword_matcher

response = transword_matcher(
    user_input="Translate to Italian",
    api_key="your_llm7_api_key_here"
)
```

## Parameters

- `user_input` (str): The user input text to process
- `llm` (Optional[BaseChatModel]): LangChain LLM instance (defaults to ChatLLM7)
- `api_key` (Optional[str]): API key for LLM7 service (if using default LLM)

## Default LLM

The package uses ChatLLM7 from [langchain_llm7](https://pypi.org/project/langchain-llm7/) by default. The free tier rate limits are sufficient for most use cases.

To get a free API key for LLM7, register at: https://token.llm7.io/

## Error Handling

The function raises a `RuntimeError` if the LLM call fails or pattern matching is unsuccessful.

## Development

Issues and contributions welcome at: https://github.com/chigwell/transword-matcher

## Author

Eugene Evstafev  
hi@euegne.plus
narrativeparser 2025.12.21083854
The package aims to help users analyze and understand nuanced narratives or statements by distinguishing between factual accounts and imaginative interpretations. Given a text input, it will process t
License: MIT
Requires Python: >=3.9

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


A Python package for analyzing and understanding nuanced narratives by distinguishing between factual accounts and imaginative interpretations.

## Installation

```bash
pip install narrativeparser
```

## Usage

The package provides a function `narrativeparser` that processes input text and returns a structured representation separating factual and imaginative elements.

### Basic Example

```python
from narrativeparser import narrativeparser

user_input = "Your text to analyze here..."
result = narrativeparser(user_input)
print(result)
```

### Using a Custom LLM

You can use any LangChain-compatible LLM by passing it to the `llm` parameter:

```python
from langchain_openai import ChatOpenAI
from narrativeparser import narrativeparser

llm = ChatOpenAI()
user_input = "Your text to analyze here..."
response = narrativeparser(user_input, llm=llm)
```

```python
from langchain_anthropic import ChatAnthropic
from narrativeparser import narrativeparser

llm = ChatAnthropic()
user_input = "Your text to analyze here..."
response = narrativeparser(user_input, llm=llm)
```

```python
from langchain_google_genai import ChatGoogleGenerativeAI
from narrativeparser import narrativeparser

llm = ChatGoogleGenerativeAI()
user_input = "Your text to analyze here..."
response = narrativeparser(user_input, llm=llm)
```

### API Key Configuration

The package uses [ChatLLM7](https://pypi.org/project/langchain-llm7/) by default. You can provide your API key in multiple ways:

1. Via environment variable:
```bash
export LLM7_API_KEY="your_api_key_here"
```

2. Directly in code:
```python
from narrativeparser import narrativeparser

user_input = "Your text to analyze here..."
response = narrativeparser(user_input, api_key="your_api_key_here")
```

Get a free API key by registering at [https://token.llm7.io/](https://token.llm7.io/)

## Parameters

- `user_input` (str): The text input to process
- `llm` (Optional[BaseChatModel]): LangChain LLM instance (defaults to ChatLLM7)
- `api_key` (Optional[str]): API key for LLM7 (if using default LLM)

## Default LLM

The package uses ChatLLM7 by default, which provides sufficient rate limits for most use cases. For higher rate limits, provide your own API key.

## Issues

Report issues and feature requests at [GitHub Issues](https://github.com/chigwell/narrativeparser/issues)

## Author

Eugene Evstafev - hi@euegne.plus
fiction-vs-fact 2025.12.21083650
The package aims to help users analyze and understand nuanced narratives or statements by distinguishing between factual accounts and imaginative interpretations. Given a text input, it will process t
License: MIT
Requires Python: >=3.9

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


A Python package to help analyze and differentiate nuanced narratives or statements by identifying which parts are factual and which are imaginative or speculative. Ideal for literary analysis, scriptwriting, or clarifying misleading information by clearly distinguishing between objective reality and creative interpretation.

## Installation

Install the package via pip:

```bash
pip install fiction_vs_fact
```

## Usage

Here's an example of how to use the package in your Python code:

```python
from fiction_vs_fact import fiction_vs_fact

# Example user input
text_input = "In the story, John claims he saw a dragon flying over the city, but eyewitnesses report no such event."

# Process the input to separate facts from fictional elements
results = fiction_vs_fact(user_input=text_input)

print(results)
```

## Function Parameters

- `user_input` (str): The text containing statements or narratives to analyze.
- `llm` (Optional[BaseChatModel]): Optional. A custom language model instance to use. Defaults to using `ChatLLM7` if not provided.
- `api_key` (Optional[str]): Optional. API key for the LLM service. If not provided, it will attempt to read the `LLM7_API_KEY` environment variable.

## Underlying LLM

The package utilizes `ChatLLM7` from [langchain_llm7](https://pypi.org/project/langchain-llm7/) by default.

## Custom LLM Usage

You can pass your own language model instance to the function. For example:

```python
from langchain_openai import ChatOpenAI
from fiction_vs_fact import fiction_vs_fact

llm = ChatOpenAI()

response = fiction_vs_fact(
    user_input="Some intriguing story...",
    llm=llm
)
```

Similarly, for other providers:

```python
from langchain_anthropic import ChatAnthropic
from fiction_vs_fact import fiction_vs_fact

llm = ChatAnthropic()

response = fiction_vs_fact(
    user_input="Some intriguing story...",
    llm=llm
)
```

## Rate Limits and API Keys

The package defaults to the free tier limits of LLM7. For higher limits, obtain an API key at [LLM7 Token Service](https://token.llm7.io/) and set it via environment variable `LLM7_API_KEY` or pass it directly:

```python
response = fiction_vs_fact(
    user_input="Some input...",
    api_key="your_api_key"
)
```

## Resources

- [GitHub issues](https://github.com/your-repo/fiction-vs-fact/issues)
- Author: Eugene Evstafev
- Email: hi@evstafev.plus
- GitHub: [chigwell](https://github.com/chigwell)
updatexplorer 2025.12.21083607
A new package designed to interpret and extract structured technical insights from user-submitted hardware and software update summaries. It processes concise text inputs about hardware support change
License: MIT
Requires Python: >=3.9

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


A Python package designed to interpret and extract structured technical insights from user-submitted hardware and software update summaries.

## Features

- Processes concise text inputs about hardware support changes or driver updates
- Outputs detailed, organized reports highlighting key components affected
- Provides compatibility considerations and recommended actions
- Ensures clarity for system administrators or developers

## Installation

```bash
pip install updatexplorer
```

## Usage

```python
from updatexplorer import updatexplorer

# Example with default LLM (ChatLLM7)
response = updatexplorer("Your update summary text here")

# Example with custom LLM (OpenAI)
from langchain_openai import ChatOpenAI
llm = ChatOpenAI()
response = updatexplorer("Your update summary text here", llm=llm)

# Example with custom LLM (Anthropic)
from langchain_anthropic import ChatAnthropic
llm = ChatAnthropic()
response = updatexplorer("Your update summary text here", llm=llm)

# Example with custom LLM (Google)
from langchain_google_genai import ChatGoogleGenerativeAI
llm = ChatGoogleGenerativeAI()
response = updatexplorer("Your update summary text here", llm=llm)
```

## 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, the environment variable `LLM7_API_KEY` will be used.

## Default LLM

The package uses `ChatLLM7` from `langchain_llm7` by default. You can safely pass your own LLM instance if you want to use another LLM.

## Rate Limits

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:

```python
response = updatexplorer("Your update summary text here", api_key="your_api_key")
```

You can get a free API key by registering at [LLM7](https://token.llm7.io/).

## Author

- **Eugene Evstafev**
  - GitHub: [chigwell](https://github.com/chigwell)
  - Email: hi@eugene.plus

## Issues

If you encounter any issues, please report them on the [GitHub issues page](https://github.com/chigwell/updatexplorer/issues).