semvec/pypi-packages huggingface dataset:
hellojp 0.0.3
Example PyPI package

## JFrog example project

This is an example python project demonstrating how to publish a module to Artifactory.

## Configuration

To resolve packages from Artifactory using pip, add the following to ~/.pip/pip.conf:
```
[global]
index-url = https://<Artifactory-url>/artifactory/api/pypi/<PyPI-Repository>/simple
local/simple
```

## Installation

Run the following commands to build & publish your module:
```
source venv/bin/activate
pip install twine
python setup.py sdist bdist_wheel
pip install dist/hellojp-0.0.1-py3-none-any.whl --force-reinstall
hellojp

twine upload dist/*
https://pypi.org/project/hellojp/0.0.2/
pip install hellojp==0.0.2

```
uzbek-stopwords 0.0.1
A list of Uzbek stopwords for the Uzbek language
Requires Python: >=3.6

# Uzbek Stopwords

A Python package providing a list of stopwords in the Uzbek language, useful for natural language processing (NLP) tasks like text cleaning, tokenization, and analysis.

## Installation

You can install this package using pip once it’s published on PyPI:

```bash
pip install uzbek-stopwords
modo-code 0.2.6
Modo code assistant client
Requires Python: <3.13,>=3.10

Modo code assistant client **Beta**


## Overview

This project provides a command-line interface for managing projects within a system called Modo Code. Users can initialize projects, ask questions 
related to those projects, and receive AI-generated responses.

## Features

- **Initialize a Project**: Users can create a new project with a specified name and programming language.
- **Ask Questions**: Once a project is initialized, users can pose questions related to their projects and receive AI-generated responses.

## Supported Languages
``` Python - C# - Typescript - Javascript - Go ```


## Installation


1. **Install modo:**

   ```bash
   pip install modo-code
   ```

2. **Authenticate with Modo Code:**
   Run the following command to log in:

   ```bash
   modo login
   ```

   * IF you need credential to try it contact me: mohamadmohamadi249@gmail.com

## Usage

1. **Initialize a Project:**

   Run the following command at root of project to start the project initialization process:

   ```bash
   modo init
   ```

   Follow the prompts to provide the project name and language.

2. **Ask a Question:**

   After initializing a project, you can ask questions like this:

   ```bash
   modo ask_question
   ```

## Contributing

If you'd like to contribute to the project, please fork the repository and submit a pull request with your proposed changes.

## License

This project is licensed under the MIT License

## Check list
- [ ] **Support new languages**
   - [ ] C#
   - [ ] GoLang
   - [x] Dart
   - [ ] PHP

- [ ] **Update command**
   - [ ] New command to update librarry
browserhand 0.1.2
AI-powered browser automation with natural language
Requires Python: >=3.7

# BrowserHand

BrowserHand is an AI-powered Python library that allows you to control web browsers using natural language. Built on top of Playwright, it provides a simple and intuitive API to automate web interactions without having to write complex automation code.

## Features

- 🧠 **Natural Language Control**: Control browsers using plain English instructions
- 🔍 **Smart Data Extraction**: Extract structured data from web pages with simple prompts
- 🔎 **DOM Observation**: Intelligently identify interactive elements on a page
- ⚡ **Fast & Reliable**: Built on Playwright for cross-browser support and reliability
- 🔗 **Works with existing Playwright code**: Integrate with your existing Playwright automation

## Installation

```bash
pip install browserhand
```

BrowserHand requires Python 3.7+.

After installing, you'll need to install the Playwright browsers:

```bash
playwright install
```

## Quick Start

```python
from browserhand import BrowserHand
from langchain_openai import ChatOpenAI

# Initialize a chat model
llm = ChatOpenAI(model="gpt-4o", temperature=0, api_key="your-openai-api-key")

# Initialize BrowserHand with the model
browser = BrowserHand(llm=llm)

try:
    # Navigate to a website
    browser.goto("https://www.example.com")
    
    # Use natural language to perform actions
    browser.Act("Click on the 'Learn more' button and then scroll down")
    
    # Extract data using natural language
    data = browser.Extract(
        "Find the main heading and the first paragraph of text", 
        {"heading": "string", "paragraph": "string"}
    )
    print(data)
    
    # Get interactive elements
    elements = browser.Observe()
    print(f"Found {len(elements)} interactive elements")
    
finally:
    browser.close()
```

## API Reference

### BrowserHand Class

The main class for browser automation with natural language.

```python
browser = BrowserHand(
    llm=None,              # Any LangChain chat model (required)
    headless=False          # Run browser in headless mode
)
```

#### Core Methods

- **goto(url: str) -> None**: Navigate to the specified URL.
- **Act(prompt: str) -> Dict[str, Any]**: Perform actions described in natural language.
- **Extract(instruction: str, schema: Dict[str, str]) -> Dict[str, Any]**: Extract data from the page.
- **Observe() -> List[Dict[str, Any]]**: Get interactive elements on the page.
- **close() -> None**: Close the browser and clean up resources.

## Supported LLM Providers

BrowserHand supports any chat model from the LangChain ecosystem, including:

- OpenAI (via `langchain_openai`)
- Azure OpenAI (via `langchain_openai`)
- Anthropic (via `langchain_anthropic`)

## Command Line Interface

BrowserHand includes a command line interface:

```bash
# Navigate and perform an action
browserhand --url "https://www.example.com" --action "Click on the first button"

# Extract data
browserhand --url "https://www.example.com" --extract "Get the main heading" --schema "heading:string"
```

## License

This project is licensed under the MIT License - see the LICENSE file for details.