semvec/pypi-packages huggingface dataset:
swarm-rqa-test 0.1.8
SWARM_RQA_TEST

# **SWARM Inference Module**

[![Upload Python Package](https://github.com/saandeepa93/SWARM_lib/actions/workflows/python-publish.yml/badge.svg)](https://github.com/saandeepa93/SWARM_lib/actions/workflows/python-publish.yml)

## **Setup**

```
conda create -n <env-name> --file requirements.txt
```

  + Ensure to fill in your \<env-name>

## **Inference**
```
python inference.py --dir <dir_path>
```

+ `<dir_path>` should be the path to set of csv files for which you'd like to compute the predictions

+ The final csv file with predictions will be saved under `./data/<dir_name>.csv`
atsphinx-toybox 2025.1.21
Miscellaneous sphinx-extension collection of attakei' trials.
Requires Python: >=3.9

===============
atsphinx-toybox
===============

Miscellaneous sphinx-extension collection of attakei' trials.

Important note
==============

* This is *lab-style* package.
  Subpackages will be stopped maintenance if it can work as singile package.
* This is calver versioning.

Getting started
===============

.. code:: console

   pip install atsphinx-toybox

.. code:: python

   extensions = [
       ...,  # Your extensions
       "atsphinx.toybox",
   ]
league-exp-util 0.1.0
A utility to calculate League of Legends experience points.
Requires Python: >=3.6
Keywords: league of legends xp calculator game utilities

# League Experience Utility

This package provides tools to calculate League of Legends experience points based on game duration and outcomes with consideration to First-Win-of-The-Day rewards.

## Installation

```bash
pip install league-exp-util
```
## Usage

```Python
from league_exp_util.exp_calculator import find

result = find(target_xp=5000, game_length=30, fwotd=1)
print(result)  # {'min': 21, 'max': 26, 'avg': 23}
```
googlesearch-python 1.3.0
A Python library for scraping the Google search engine.
Requires Python: >=3.6

# googlesearch
googlesearch is a Python library for searching Google, easily. googlesearch uses requests and BeautifulSoup4 to scrape Google. 

## Installation
To install, run the following command:
```bash
python3 -m pip install googlesearch-python
```

## Usage
To get results for a search term, simply use the search function in googlesearch. For example, to get results for "Google" in Google, just run the following program:
```python
from googlesearch import search
search("Google")
```

## Additional options
googlesearch supports a few additional options. By default, googlesearch returns 10 results. This can be changed. To get a 100 results on Google for example, run the following program.
```python
from googlesearch import search
search("Google", num_results=100)
```
If you want to have unique links in your search result, you can use the `unique` option as in the following program.
```python
from googlesearch import search
search("Google", num_results=100, unique=True)
```
In addition, you can change the language google searches in. For example, to get results in French run the following program:
```python
from googlesearch import search
search("Google", lang="fr")
```
You can also specify the region ([Country Codes](https://developers.google.com/custom-search/docs/json_api_reference#countryCodes)) for your search results. For example, to get results specifically from the US run the following program:
```python
from googlesearch import search
search("Google", region="us")
```
If you want to turn off the safe search function (this function is on by default), you can do this:
```python
from googlesearch import search
search("Google", safe=None)
```
To extract more information, such as the description or the result URL, use an advanced search:
```python
from googlesearch import search
search("Google", advanced=True)
# Returns a list of SearchResult
# Properties:
# - title
# - url
# - description
```
If requesting more than 100 results, googlesearch will send multiple requests to go through the pages. To increase the time between these requests, use `sleep_interval`:
```python
from googlesearch import search
search("Google", sleep_interval=5, num_results=200)
```

```
If requesting more than 10 results, but want to manage the batching yourself? 
Use `start_num` to specify the start number of the results you want to get:
```python
from googlesearch import search
search("Google", sleep_interval=5, num_results=200, start_result=10)
```

If you are using a HTTP Rotating Proxy which requires you to install their CA Certificate, you can simply add `ssl_verify=False` in the `search()` method to avoid SSL Verification.
```python
from googlesearch import search

proxy = 'http://API:@proxy.host.com:8080/'

j = search("proxy test", num_results=100, lang="en", proxy=proxy, ssl_verify=False)
for i in j:
    print(i)
```
ssakssree 0.1.2
A collection of statistics-based business analysis libraries by Danda Company, a professional analytics firm
Requires Python: >=3.6

# ssakssree

A collection of statistics-based business analysis libraries by Danda Company, a professional analytics firm

## Installation

```bash
pip install ssakssree
```

## Key Features

- Mixed Model-based Conjoint Analysis
- Price scaling support
- Baseline level specification
- Interaction analysis between attributes
- Price range recommendation based on target rating

## Usage

```python
from ssakssree.recommender import MixedConjointPriceRecommender
import pandas as pd

# Config
config = {
    'respondent_col': 'RespondentID',
    'rating_col': 'Rating',
    'price_col': 'Price',
    'categorical_cols': ['Brand', 'SolutionQuality', 'Difficulty', 'Design'],
    'interaction_cols': ['Brand', 'Design'],
    'price_scale_factor': 1000,
    'baseline_levels': {
        'Brand': 'Local',
        'SolutionQuality': 'Basic',
        'Difficulty': 'Easy',
        'Design': '단색'
    }
}

# Load data & fit model
df = pd.read_csv("your_data.csv")
recommender = MixedConjointPriceRecommender(config)
recommender.fit_model(df)

# Find price range for a specific attribute combination
attributes = {
    'Brand': 'National',
    'SolutionQuality': 'Advanced',
    'Difficulty': 'Easy',
    'Design': '단색'
}

# Find price range for a specific attribute combination
price_range = recommender.find_price_range(
    attributes,
    price_min=5000,
    price_max=30000,
    threshold=4.5
)
print(f"Recommended price range: {price_range}")
```
stan-language-server 0.1.0
Language server implementation for STAN, using pygls.
Requires Python: <4.0,>=3.9

# stan-language-server

A server implementing the Language Server Protocol for the STAN probabilistic
programming language. Currently in a very alpha state.

Note: You must have the stan compiler [stanc3 binary](https://github.com/stan-dev/stanc3/releases)
on your path. It should be named `stanc`.

## Installing

Assuming you have poetry installed, run:
```sh
make
```

This runs:
```sh
poetry build
pip3 install dist/stan_language_server-0.1.0-py3-none-any.whl --force-reinstall
```

Which is appropriate for testing but you might want to install the wheel in a venv
or somewhere else.

## How to use

I am using neovim, so here's how I'm testing the server so far. This expects that
you are using [lspconfig](https://github.com/neovim/nvim-lspconfig) to manage LSPs.
I added this to my neovim init.

```lua
local lspconfig = require 'lspconfig'
local configs = require 'lspconfig.configs'

if not configs.stan_language_server then
  configs.stan_language_server = {
    default_config = {
      cmd = { 'stan-language-server' },
      filetypes = { 'stan' },
      root_dir = function(fname)
        return lspconfig.util.find_git_ancestor(fname)
      end,
      settings = {},
      single_file_support = true,
    },
  }
end

lspconfig.stan_language_server.setup {}
```

Until I write the neovim client, you will also have to set the filetype.

```lua
vim.filetype.add {
  extension = {
    stan = 'stan',
  },
}
```

## Details

Diagnostics are implemented using the STAN compiler, stanc.
Warnings and errors are collected and sent as diagnostics.

Completions are semi-automatically collected via the script `extract_function_sigs.py'.
This script should be run in the root directory of the STAN documentation, found at
https://github.com/stan-dev/docs. It will generate the complete list of documented
STAN functions.

Keyword completions are manually added from the following page:
https://mc-stan.org/docs/reference-manual/expressions.html#reserved-names.
The current list of keyword completions are found in the following 
[Google Sheets link](https://docs.google.com/spreadsheets/d/1MJqSPgcLxSIKI7qxCH1gVq3SKGUQL25dYww3BDaHERs/edit?usp=sharing).
Variable completions are currently limited to variables declared in `data` or `(transformed) parameters` or `quantities`.

## Roadmap

- [ ] LSP implementation
    - [x] Completion
    - [x] Diagnostics
    - [ ] Hover
    - [ ] Rename
    - [ ] Goto Declaration
    - [ ] Goto Definition
    - [ ] Probably more (snippets?) (folds?)
- [ ] Clients
    - [ ] VSCode extension
    - [ ] Neovim (lspconfig+mason)
    - [ ] probably more
kitcore 1.1.6
A short description of the package
Requires Python: >=3.12

kitcore is a lightweight Python library for machine learning algorithms like Linear Regression, Logistic Regression, Random Forest, Decision Trees, and KNN. 
Install via pip install kitcore and use simple API calls to fit and predict on any dataset. Itâ€™s designed to be easy-to-use, flexible, and scalable.
Version = 1.1.6
proxytunnel 0.1.1
fast forward proxy tunnel
Requires Python: >=3.6

# ProxyTunnel Wrapper

A Python wrapper for proxytunnel.exe that automatically manages the executable and provides a simple interface for port forwarding.

## Installation

```bash
pip install proxytunnel
```

## Features

- Automatic download and management of proxytunnel.exe
- Simple Python interface for port forwarding
- Automatic cleanup of processes
- Find available ports automatically
- Process status monitoring
- Windows support
- Background process management

## Usage

### Basic Port Forwarding

```python
from proxytunnel import ProxyTunnel

# Create a ProxyTunnel instance
# This will automatically download proxytunnel.exe if it's not present
proxy = ProxyTunnel()

# Forward local port 8080 to remote proxy example.com:3128
process = proxy.forward(local_port=8080, remote_proxy="user:pass@example.com:3128")

# The process runs in the background
# To stop it:
process.terminate()
```

### Finding Available Ports

```python
from proxytunnel import ProxyTunnel

proxy = ProxyTunnel()

# Get a random available port
free_port = proxy.free_port()
print(f"Found available port: {free_port}")

# Use the free port for forwarding
process = proxy.forward(local_port=free_port, remote_proxy="http://user:pass@example.com:3128")
```

### Process Management

```python
from proxytunnel import ProxyTunnel

proxy = ProxyTunnel()
process = proxy.forward(local_port=8080, remote_proxy="http://user:pass@example.com:3128")

# Check if the process is running
if proxy.is_running():
    print("Proxy tunnel is active")

# Kill the process
proxy.kill()

# Verify process is stopped
if not proxy.is_running():
    print("Proxy tunnel is stopped")
```

### Automatic Cleanup

The ProxyTunnel wrapper automatically handles process cleanup:
- When the ProxyTunnel object is destroyed
- When the program exits
- When starting a new forward process (kills existing process)

```python
from proxytunnel import ProxyTunnel

# Create proxy instance
proxy = ProxyTunnel()

# Start forwarding
process1 = proxy.forward(local_port=8080, remote_proxy="example.com:3128")

# Starting another forward will automatically kill the previous process
process2 = proxy.forward(local_port=8081, remote_proxy="example.com:3128")

# No need to manually clean up - it's handled automatically when:
# - The program exits
# - The proxy object is destroyed
# - A new forward process is started
```

## Requirements

- Python 3.6 or higher
- Windows operating system
- Internet connection (for downloading proxytunnel.exe)

## License

This project is licensed under the MIT License - see the LICENSE file for details.