semvec/pypi-packages huggingface dataset:
fixnow 0.1.2
AI-powered Git commit fixer
Requires Python: >=3.7

# 🚀 FixNow – AI-powered Git commit fixer

Detect & fix errors before you commit! 🛠️

FixNow is a CLI tool that detects potential errors in your code at commit time and suggests fixes, so you can avoid pushing bugs.

## ✨ Features

- ✅ Detects errors in your code before committing
- ✅ Provides AI-powered fix suggestions
- ✅ Works as a Git pre-commit hook
- ✅ Supports multiple programming languages

## 📦 Install FixNow (coming soon!)

```sh
$ npm install -g fixnow
```

## 🚀 Usage

Run FixNow before committing:

```sh
$ fixnow check
```

Or set it up as a Git pre-commit hook:

```sh
$ fixnow install
```

## 📌 Why FixNow?

- 💡 Never push broken code again!
- ⚡ Works automatically with your Git workflow
- 🚀 Saves time by catching mistakes early

## 🌟 Star this repo!

If you find FixNow useful, give it a ⭐ on GitHub! 👉 [GitHub.com/Structax/fixnow](https://github.com/Structax/fixnow)

🚀 Built by Structax – Indie Developer in Japan
llm-to-cli 0.1.8
simple llm based tools to access from cli
Requires Python: <4.0,>=3.11

# LLM-cli
A lightweight Command Line Interface (CLI) for interacting with Large Language Models (LLMs) using LiteLLM.


## 💡 Why This Project?
Sometimes network constraints or data limitations make it difficult to access large language models via web interfaces. This CLI provides a lightweight, flexible solution for LLM interactions directly from the terminal.


## 🚀 Features

- **Simple CLI Interface**: Easily chat with different LLMs from your terminal
- **Input**: Pipe inputs or redirect file text.
- **Multiple Chat Modes**:
  - Direct single-message chat
  - Interactive chat UI with markdown rendering
  - Image support for vision-capable models
- **Flexible Configuration**: Customize model, temperature, and system prompts
- **Easy Configuration Management**: Update settings with a simple command
- **Sessions** : Logs chat sessions, can be resumed saved chat later.

## 🔧 Prerequisites

- Api keys to the llms, set api keys as environment variables

## 💾 Installation

1. Via Pip
```bash
pip install llm-to-cli
```
Or 

2. From Repo
```bash
# Clone the repository
git clone https://github.com/tikendraw/llm-cli.git
cd llm-cli

# Install 
pip install .
```

## 🖥️ Usage

### Basic Chat

* Send a single message to an LLM:

  ```bash
  llm-cli chat "Hello, how are you?"
  ```
* Pipe input
  ```bash
  echo "what is 34th prime number" | llm-cli chat
  ```
* File redirection
  ```bash
  llm-chat chat < some_file_with_question.txt
  ```

### Interactive Chat UI

* Start an interactive chat session:

  ```bash
  llm-cli chatui
  ```

### Image Support

* Add image
  ```bash
  llm-cli chat --image path/to/image/or/url
  ```

### Configuration

* View current configuration:
  ```bash
  llm-cli config
  ```

* Update configuration:
  ```bash
  llm-cli config model "anthropic/claude-3-haiku"
  llm-cli config temperature 0.7
  ```

## 🛠️ Commands

- `chat`: Send a single message
- `chatui`: Interactive chat 
- `config`: Manage CLI configuration
- `history`: See and manage history

## 🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## 🖹 License
The MIT one.
ajh-finance-online-data-scraper 0.1.0
Library for scraping financial data from online sources

Hello! This is a Python library for scraping various forms of public finance data in the USA. The code is shown in this GitHub repository: https://github.com/AvilashaHaldar/ajh_finance_scraper_python_library. Currently, this library can:

1. Scrape forward 1 and 3 month SOFR curves

This can be done by doing:

```
from ajh_finance_online_data_scraper import InterestRatesScrapedData
forward_SOFR_curves_df, allowed_SOFR_lengths_months = InterestRatesScrapedData().get_scraped_SOFR_curves()
```

forward_SOFR_curves_df is a Pandas DataFrame containing the 1-month and 3-month forward SOFR rates for the next 10 years. allowed_SOFR_lengths_months is a NumPy array containg the allowed month lengths for the SOFR curves (currently only 1 and 3).

2. Getting daily closing stock prices for the past 3 years

```
from ajh_finance_online_data_scraper import HistoricalDailyStockPricesAPI
closing_prices_df = HistoricalDailyStockPricesAPI().get_historical_prices_df(ticker_symbol)
```

closing_prices_df is a Pandas DataFrame of daily closing prices over the past 3 years containing the columns [Close, Log_Close, Daily_Returns, Annualized_Hist_Volatility, Annualized_Mean_Daily_Return]. Volatility and mean are rolling values calculated over a 252-day period. (We assume 252 business days in a year.)

3. Compute a few key statistics from the past day

```
from ajh_finance_online_data_scraper import HistoricalDailyStockPricesAPI
mu, sigma, latest_price = HistoricalDailyStockPricesAPI().get_main_stats_from_hist_prices(ticker_symbol)
```

mu is the annualized mean daily log return of the last business day calculated for the last 252 days, sigma is the annualized standard deviation of daily log returns over the last 252 days, and latest_price is the last closing price.

4. Scrape US treasury bill rates

```
from ajh_finance_online_data_scraper import InterestRatesScrapedData
treasury_bill_rates_df = InterestRatesScrapedData().get_scraped_treasury_bill_rates()
```

Here, we scrape US treasury bill rates from the website https://home.treasury.gov/resource-center/data-chart-center/interest-rates/TextView?type=daily_treasury_bill_rates&field_tdr_date_value=2025 and return the rates in a pandas dataframe.
airobot-api-client 0.4.1
An API client for the Airobot Thermostat local API
Requires Python: >=3.8

# Python Airobot API client

A simple Python API client for interacting with [Airobot smart thermostats](https://airobothome.com/en/smart-thermostat/). 

## Installing

Install with pip
```
pip install airobot_api_client
```

## Usage

There are two versions of the client available. Synchronous and asynchrounous.

### Sync version

```
from airobot_api_client.api import AirobotAPI
from airobot_api_client.models import ThermostatSettingsUpdateInput

api = AirobotAPI(<THERMOSTAT_IP>, <USERNAME>, <PASSWORD>)

settings = api.get_settings()
status = api.get_status()

new_settings = ThermostatSettingsUpdateInput(BOOST=True)
updated_settings = api.set_settings(new_settings)
```

### Async version

```
import asyncio
from airobot_api_client.async_api import AsyncAirobotAPI
from airobot_api_client.models import ThermostatSettingsUpdateInput

async def async_main():
    async with AsyncAirobotAPI(<THERMOSTAT_IP>, <USERNAME>, <PASSWORD>) as api:

        settings = await api.get_settings()
        status = await api.get_status()

        new_settings = ThermostatSettingsUpdateInput(BOOST=True)
        updated_settings = await api.set_settings(new_settings)

asyncio.run(async_main())
```
image-style-repaint 0.1.2
Generate styled image using bailian/wanx-style-repaint-v1
Requires Python: >=3.10

# Image Style Repaint

Generate styled image using wanx-style-repaint-v1

## Usage
```
> pip install image-style-repaint
> image-style-repaint --api_token <API TOKEN> --output output.jpg <IMAGE URL>
OR
> isr --api_token <API TOKEN>  --output output <IMAGE URL>
```

or you can use.env file to store your api key, and then run the command:
```
DASHSCOPE_API_KEY=<SK TOKEN>
```
jira-easy 1.0.2
A simple Python library for fetching JIRA issues using JQL.
Requires Python: >=3.6

# jira_easy

A simple Python library that performs basic JIRA operations (like fetching and creating issues via JQL).

## Installation

Install directly from source:
```bash
pip install jira-easy
```

## Usage

# Fetching

```python
from jira_easy import JIRAClient

# Provide your JIRA URL and API token
jira_url = "https://your-jira-instance.atlassian.net/rest/api/2/search"
api_token = "YOUR_JIRA_API_TOKEN"

# Initialize the client
client = JIRAClient(jira_url, api_token)

# Define your JQL query
jql_query = 'project = "PROJ" AND status = "Open" ORDER BY key ASC'

# Fetch issues matching the query
issues = client.fetch_issues(jql_query)
print(f"Number of issues found: {len(issues)}")
for issue in issues:
    print(issue.get("key"), "-", issue["fields"].get("summary"))
```

# Creating

```python
from jira_easy import JIRAClient

# Use your actual JIRA URL base (without /search or /issue appended).
# Example: "https://your-domain.atlassian.net/rest/api/2"
jira_base_url = "https://your-domain.atlassian.net/rest/api/2"
api_token = "YOUR_JIRA_API_TOKEN"

# Initialize the JIRA client
client = JIRAClient(jira_base_url, api_token)

# Create a new issue with a specified priority
created_issue = client.create_issue(
    project_key="MYPROJECT",
    summary="Bug: App crashing on startup",
    description="Steps to reproduce...\n1. ...\n2. ...\netc.",
    issue_type="Bug",
    priority="High"
)

# The response JSON contains details about the new issue
print("New issue key:", created_issue.get("key"))

```
pyomo-windows 0.0.5
Utilities to install pyomo solvers in windows without anaconda
Requires Python: >=3.11

# pyomo-windows

Utilities to set up a pyomo environment in Windows. Installs `glpk`, `ipopt`and `cbc` solvers.

## Install

In your environment, install pyomo_environment with
```commandline
pip install pyomo_windows
```
## Download solvers
Before using any solver, they must be downloaded first. You can download solvers using the `DownloadSolvers` class:
```python
from pyomo_windows.solvers import DownloadSolvers
downloader = DownloadSolvers()
downloader.download_glpk()      # Download glpk
downloader.download_cbc()       # Download coin-cbc
downloader.download_ipopt()     # Download ipopt

```

## Use solvers
Create your pyomo model and before executing it, call `get_solver` to get the desired solver. Remember that solver must be downloaded first as explained [here](#download-solvers).

Example:

```python
# Create model normally
import pyomo.environ as pyo

model = pyo.ConcreteModel()
# Solve model
from pyomo_windows.solvers import SolverManager

solver_manager = SolverManager()
solver = "glpk"  # Or "cbc" or "ipopt"
opt = solver_manager.get_solver(solver)
res = opt.solve(model)
# Process your results...
```
### Troubleshooting
You might face errors in the first execution.
If in your install you cannot write in the default folder, try
Optionally, if you want models to be downloaded in a different location, by passing folder to `SolverManager`.
For example:
```python
# Create model normally
import pyomo.environ as pyo

model = pyo.ConcreteModel()
# Solve model
from pyomo_windows.solvers import SolverManager

solver_manager = SolverManager('write a valid folder path here')
solver = "glpk"  # Or "cbc" or "ipopt"
opt = solver_manager.get_solver(solver)
res = opt.solve(model)
# Process your results...
```


## Testing
Run tests in `test_solvers.py`. First execution will be slow as models have to be downloaded
xjtu-enre 0.1.0
supports the extraction of entities and their dependencies from systems written in multiple languages, enables the customization of dependencies of interest to the user, and makes implicit dependencies explicit.
Requires Python: >=3.10

# ENRE-py

ENRE (ENtity Relationship Extractor) is a tool for extraction of code entity dependencies or relationships from source code. The resolved python entity types include:


For more detailed information on python entities and dependencies, see the [doc](./docs) to get definitions and examples.
## Features
- Control flow analysis for python

## Supported Language
|Language|Supported Version|
|-|-|
|Python|3.x|

## Getting Started
> ENRE-python has been tested to be worked with python3.x.




## Usage
Use `-h` or `--help` option to check usable options.
```shell
usage: enre.exe [-h] [--profile] [--cfg] [--compatible] [--builtins BUILTINS] [--cg] [root path]

positional arguments:
  root path            root package path

options:
  -h, --help           show this help message and exit
  --profile            output consumed time in json format
  --cfg                run control flow analysis and output module summaries
  --compatible         output compatible format
  --builtins BUILTINS  builtins module path
  --cg                 dump call graph in json

```

- You can use enre to analyze a python package:
```
enre.exe <dir>
```

- Analyzing a single python module:
```
enre.exe <py-file>
```

- Use control flow functionality to get more accurate dependency.
```shell
enre.exe <dir> --cfg
```

- Output call graph when after control flow analysis
```shell
enre.exe <dir> --cfg --cg
```

## Documentation

Check the [doc](./docs) to get detail about entities and dependencies.

## Building
Use Pyinstaller to build enre into executable binary:
```shell
pyinstaller -F .\enre\__main__.py
```