semvec/pypi-packages huggingface dataset:
paperfetch 0.1.0
Python script to fetch research papers from PubMed API and save as CSV.
Requires Python: >=3.13

# PubMed Paper Fetcher

This Python program fetches research papers from PubMed based on a user-specified query, filters papers with authors affiliated with pharmaceutical or biotech companies, and outputs the results as a CSV file.

## 🚀 Features
- ✅ Fetches research papers from PubMed API.
- ✅ Filters papers with authors from pharmaceutical/biotech companies.
- ✅ Saves the output as a CSV file.
- ✅ Command-line interface (CLI) built using Python argparse.
- ✅ Easy to use with Poetry for dependency management.

---

## 📥 Installation

1. **Clone the repository**:
   ```bash
   git clone https://github.com/yourusername/pubmed-paper-fetcher.git
   cd pubmed-paper-fetcher
grepjson 0.2.2
Interactively inspect or process JSON/JSONL data from pipe.
Keywords: json debug cli

# grepjson

**Interactive JSON processor with built-in debugger**

`grepjson` is a command-line tool designed to help developers interactively inspect and process JSON/JSONL data. It integrates Python's built-in `pdb` debugger, allowing you to explore JSON objects in real-time or execute custom Python snippets directly from the command line.

## Features

- **Interactive Debugging**: Drop into a `pdb` session to inspect JSON objects interactively.
- **JSONL Support**: Process JSON Lines (JSONL) format with ease.
- **Custom Execution**: Execute Python code snippets on JSON objects directly from the command line.
- **Cross-Platform**: Works on UNIX-like systems and Windows (with some limitations).
- **Pipeline Integration**: Seamlessly integrates with Unix pipelines and other CLI tools.

## Installation

Install `grepjson` via pip:

```bash
pip install grepjson
```


## Usage

### Basic Usage

Parse a JSON file and enter an interactive debug session:

```bash
cat data.json | grepjson
```

In the debug session, access the parsed JSON object as `obj`:

```plaintext
(Pdb) print(obj['key'])
```

### JSONL Support

Process a JSON Lines file and enter debug mode with all objects available as `objs`:

```bash
cat data.jsonl | grepjson --line
```

Or use a simple form:

```bash
cat data.jsonl | grepjson -l
```

### Execute Code Snippets

Extract specific fields without entering debug mode:

```bash
cat data.json | grepjson --exec "print(obj['name'])"
```

Or use a simple form:

```bash
cat data.json | grepjson -x "print(obj['name'])"
```

Process each JSON object in a JSONL file:

```bash
cat data.jsonl | grepjson -l -x "print(obj['id'])"
```



### Print Results

Automatically print the result of a code snippet:

```bash
cat data.json | grepjson -x "obj['value']" -p
```

## Examples

### Example 1: Interactive Debugging

```bash
echo '{"name": "Alice", "age": 30}' | grepjson
```

In the debug session:

```plaintext
(Pdb) print(obj['name'])
Alice
(Pdb) obj['age'] += 1
(Pdb) print(obj)
{'name': 'Alice', 'age': 31}
```

### Example 2: JSONL Processing

```bash
echo -e '{"id": 1}\n{"id": 2}\n{"id": 3}' | grepjson -l -x "print(obj['id'])"
```

Output:

```plaintext
1
2
3
```

### Example 3: Field Extraction

```bash
echo '{"name": "Bob", "details": {"age": 25}}' | grepjson -x "obj['details']['age']" -p
```

Output:

```plaintext
25
```
hypertune-param 0.1.1
A custom library for hyperparameter optimization using Grid Search, Random Search, and Bayesian Optimization.
Requires Python: >=3.6

# Hypertune

Hypertune is a Python library designed to simplify hyperparameter optimization for machine learning models. It supports different search strategies, including Grid Search, Random Search, and Bayesian Optimization, to find the best hyperparameters for your model and improve its performance.

Features

- **Grid Search**: Exhaustively searches through a manually specified grid of hyperparameters.
- **Random Search**: Randomly samples hyperparameter combinations to find optimal settings.
- **Bayesian Optimization**: Uses probabilistic models to predict the best hyperparameters and minimize the number of trials needed.

## Installation

You can install **Hypertune** using `pip` from PyPI:

```bash
pip install hypertune
```

## Usage

Here’s how to use **Hypertune** with a machine learning model:

### 1. Import the library

```python
from hypertune import Hypertune
from hypertune.grid_search import GridSearch
from hypertune.random_search import RandomSearch
from hypertune.bayesian_search import BayesianSearch
```

### 2. Define the model and parameters

```python
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris

# Load a dataset
X, y = load_iris(return_X_y=True)

# Define the model
model = RandomForestClassifier()

# Define hyperparameter search space for GridSearch
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [None, 10, 20],
    'min_samples_split': [2, 5, 10]
}
```

### 3. Run Grid Search

```python
# Create the GridSearch object
grid_search = GridSearch(model, param_grid)

# Fit the model and find the best parameters
grid_search.fit(X, y)

# Get the best hyperparameters
print("Best Hyperparameters:", grid_search.best_params_)
```

### 4. Run Random Search

```python
# Define the random search space
param_dist = {
    'n_estimators': [50, 100, 200, 300],
    'max_depth': [None, 10, 20, 30],
    'min_samples_split': [2, 5, 10, 15]
}

# Create the RandomSearch object
random_search = RandomSearch(model, param_dist)

# Fit the model and find the best parameters
random_search.fit(X, y)

# Get the best hyperparameters
print("Best Hyperparameters:", random_search.best_params_)
```

### 5. Run Bayesian Optimization

```python
# Define the hyperparameter search space for Bayesian Optimization
param_space = {
    'n_estimators': (50, 200),
    'max_depth': (1, 30),
    'min_samples_split': (2, 15)
}

# Create the BayesianSearch object
bayesian_search = BayesianSearch(model, param_space)

# Fit the model and find the best parameters
bayesian_search.fit(X, y)

# Get the best hyperparameters
print("Best Hyperparameters:", bayesian_search.best_params_)
```

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
ns-ab-test-sdk 0.1.1
A simple A/B testing SDK for recording and saving data
Requires Python: >=3

# AB Test SDK

A simple A/B testing SDK for recording and saving data.

## Installation

```bash
pip install ns_ab_test_sdk
```

## Usage

```python
from ns_ab_test_sdk import recorder

# your code...

# Record data
recorder.put("test_key", "test_value")

# your code...
```