semvec/pypi-packages huggingface dataset:
text-parsematch 2025.12.22111249
text-parsematch processes text input with pattern matching and retries to ensure structured, validated output for data extraction and content categorization.
License: MIT
Requires Python: >=3.9

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


A Python package for processing user-provided text input and returning structured, validated output using pattern matching and retries.

## Overview

This package ensures consistent and reliable formatting for applications like data extraction, content categorization, or structured response generation, without handling raw media files directly.

## Installation

```bash
pip install text_parsematch
```

## Usage

```python
from text_parsematch import text_parsematch

user_input = "Example text to process"
response = text_parsematch(user_input)

# To use your own LLM instance:
from langchain_core.language_models import BaseChatModel
from text_parsematch import text_parsematch

llm = BaseChatModel(...)  # create your own LLM instance
response = text_parsematch(user_input, llm=llm)

# For LLM7, you can also pass the api key:
from text_parsematch import text_parsematch

response = text_parsematch(user_input, api_key="your_api_key")

# Or use the default LLM7 instance with your api key:
from text_parsematch import text_parsematch

response = text_parsematch(user_input, api_key="your_api_key")
```

## Available LLM Models

By default, this package uses the ChatLLM7 from `langchain_llm7`. If you want to use another LLM, you can pass your own instance via the `llm` parameter.

Here are some examples with popular LLMs:

* OpenAI:
```python
from langchain_openai import ChatOpenAI
from text_parsematch import text_parsematch

llm = ChatOpenAI()
response = text_parsematch(user_input, llm=llm)
```

* Anthropic:
```python
from langchain_anthropic import ChatAnthropic
from text_parsematch import text_parsematch

llm = ChatAnthropic()
response = text_parsematch(user_input, llm=llm)
```

* Google Generative AI:
```python
from langchain_google_genai import ChatGoogleGenerativeAI
from text_parsematch import text_parsematch

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

## Rate Limits

The default rate limits for LLM7 free tier are sufficient for most use cases of this package. If you need higher rate limits, you can pass your own api key via environment variable `LLM7_API_KEY` or via passing it directly like `text-parsematch(user_input, api_key="your_api_key")`.

## Getting a Free API Key

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

## Issues

Report issues at: https://github.com/chigwell/text-parsematch

## Author

Eugene Evstafev (chigwell)
hi@eugene.plus
sqlalchemy-iris 0.18.2b1
InterSystems IRIS for SQLAlchemy
License: MIT
Requires Python: >=3.10
Keywords: "SQLAlchemy InterSystems IRIS"

sqlalchemy-iris
===

An InterSystems IRIS dialect for SQLAlchemy.

Pre-requisites
---

This dialect requires SQLAlchemy, InterSystems DB-API driver. They are specified as requirements so ``pip``
will install them if they are not already in place. To install, just:

```shell
pip install sqlalchemy-iris
```

Or to use InterSystems official driver support

```shell
pip install sqlalchemy-iris[intersystems]
```

Usage
---

In your Python app, you can connect to the database via:

```python
from sqlalchemy import create_engine
engine = create_engine("iris://_SYSTEM:SYS@localhost:1972/USER")
```

To use with Python Embedded mode, when run next to IRIS

```python
from sqlalchemy import create_engine
engine = create_engine("iris+emb:///USER")
```

To use with InterSystems official driver, does not work in Python Embedded mode

```python
from sqlalchemy import create_engine
engine = create_engine("iris+intersystems://_SYSTEM:SYS@localhost:1972/USER")
```

IRIS Cloud SQL requires SSLContext

```python
url = engine.URL.create(
    drivername="iris",
    host=host,
    port=443,
    username='SQLAdmin',
    password=password,
    database='USER',
)

sslcontext = ssl.create_default_context(cafile="certificateSQLaaS.pem")

engine = create_engine(url, connect_args={"sslcontext": sslcontext})
```

InterSystems IRIS
---

You can run your instance of InterSystems IRIS Community Edition with Docker

```shell
docker run -d --name iris \
 -p 1972:1972 \
 -p 52773:52773 \
 -e IRIS_USERNAME=_SYSTEM \
 -e IRIS_PASSWORD=SYS \
 intersystemsdc/iris-community:preview
```

Examples
===

IRISVector
---

```python
from sqlalchemy import Column, MetaData, Table, select
from sqlalchemy.sql.sqltypes import Integer, UUID
from sqlalchemy_iris import IRISVector
from sqlalchemy import create_engine
from sqlalchemy.orm import DeclarativeBase
import uuid

DATABASE_URL = "iris://_SYSTEM:SYS@localhost:1972/USER"
engine = create_engine(DATABASE_URL, echo=False)

# Create a table metadata
metadata = MetaData()


def main():
    demo_table = Table(
        "demo_table",
        metadata,
        Column("id", Integer, primary_key=True, autoincrement=True),
        Column("uuid", UUID),
        Column("embedding", IRISVector(item_type=float, max_items=3)),
    )

    demo_table.drop(engine, checkfirst=True)
    demo_table.create(engine, checkfirst=True)
    with engine.connect() as conn:
        conn.execute(
            demo_table.insert(),
            [
                {"uuid": uuid.uuid4(), "embedding": [1, 2, 3]},
                {"uuid": uuid.uuid4(), "embedding": [2, 3, 4]},
            ],
        )
        conn.commit()
        result = conn.execute(
            demo_table.select()
        ).fetchall()
        print("result", result)


main()
```

_Port 1972 is used for binary communication (this driver, xDBC and so on), and 52773 is for web (Management Portal, IRIS based web-applications and API's)._

The System Management Portal is available by URL: `http://localhost:52773/csp/sys/UtilHome.csp`
outline-ai 2025.12.22110945
outline-ai converts text into structured summaries, proposals, or outlines, automating publication creation with clarity and ease.
License: MIT
Requires Python: >=3.9

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


Transform user-provided text inputs into well-structured summaries, proposals, or content outlines with outline-ai.

## Introduction

outline-ai is a new package designed to revolutionize the way you create content. By leveraging language models, it generates organized and clear outputs without the need for managing media or direct document uploads. This makes it an efficient and customizable alternative to traditional platforms like Substack.

## Installation

```bash
pip install outline_ai
```

## Usage

```python
from outline_ai import outline_ai

user_input = "Create a summary of this article about AI and machine learning"
response = outline_ai(user_input)
print(response)
```

### 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, outline_ai uses the ChatLLM7 from langchain_llm7 (https://pypi.org/project/langchain-llm7/). If you want to use another LLM, you can safely pass your own llm instance by setting it like this:

```python
from langchain_openai import ChatOpenAI
from outline_ai import outline_ai

llm = ChatOpenAI()
response = outline_ai(user_input, llm=llm)
```

For example, to use the openai (https://pypi.org/project/langchain-openai/):

```python
from langchain_openai import ChatOpenAI
from outline_ai import outline_ai

llm = ChatOpenAI()
response = outline_ai(user_input, llm=llm)
```

Or, to use the anthropic (https://pypi.org/project/langchain-anthropic/):

```python
from langchain_anthropic import ChatAnthropic
from outline_ai import outline_ai

llm = ChatAnthropic()
response = outline_ai(user_input, llm=llm)
```

Or, to use the google (https://pypi.org/project/langchain-google-genai/):

```python
from langchain_google_genai import ChatGoogleGenerativeAI
from outline_ai import outline_ai

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

## Rate Limits

The default rate limits for LLM7 free tier are sufficient for most use cases of this package. If you need higher rate limits, you can pass your own API key via environment variable `LLM7_API_KEY` or directly. Get a free API key by registering at https://token.llm7.io/.

## GitHub

Check out the GitHub issues page for any further questions or issues: https://github.com/chigwell/outline-ai/issues

## Author

This package was created by Eugene Evstafev, you can contact him at hi@euegne.plus.

## Credits

Author: chigwell