semvec/pypi-packages huggingface dataset:
lusid-bundle 1.2.1
lusid-bundle is a python package that makes it quick and easy to install all of the Lusid and Luminesce sdks and dependencies.
Requires Python: >=3.12


[![pypi](https://img.shields.io/pypi/v/lusid-bundle)](https://pypi.org/project/lusid-bundle/)
[![python](https://img.shields.io/pypi/pyversions/lusid-bundle.svg)](https://pypi.org/project/lusid-bundle/)

# 1. lusid-bundle
#####  *`lusid-bundle` is a python package that makes it quick and easy to get started using Lusid and Luminesce. It bundles all packages needed to get started.*






##  1. <a name='Conveniencepackageinstallations'></a>Convenience package installations

```mermaid
graph LR;
    lusid_bundle --> luminesce_sdk_preview
    lusid_bundle --> lusid_jam
    lusid_bundle --> lusid_sdk_preview
    lusid_bundle --> fbnlab_preview
    lusid_bundle --> finbourne_access_sdk
    lusid_bundle --> finbourne_identity_sdk
    lusid_bundle --> finbourne_insights_sdk_preview
    lusid_bundle --> finbourne_sdk_utilities
    lusid_bundle --> lusid_configuration_sdk_preview
    lusid_bundle --> lusid_drive_sdk_preview
    lusid_bundle --> lusid_notifications_sdk_preview
    lusid_bundle --> lusid_scheduler_sdk_preview
    lusid_bundle --> lusid_workflow_sdk_preview
    lusid_bundle --> lusidtools
    lusid_bundle --> dve_lumipy_preview

    luminesce_sdk_preview["luminesce-sdk-preview==1.14.758"]
    lusid_jam["lusid-jam==0.1.2"]
    lusid_sdk_preview["lusid-sdk-preview==1.1.120"]
    fbnlab_preview["fbnlab-preview==0.1.108"]
    finbourne_access_sdk["finbourne-access-sdk==0.0.3751"]
    finbourne_identity_sdk["finbourne-identity-sdk==0.0.2834"]
    finbourne_insights_sdk_preview["finbourne-insights-sdk-preview==0.0.763"]
    finbourne_sdk_utilities["finbourne-sdk-utilities==0.0.10"]
    lusid_configuration_sdk_preview["lusid-configuration-sdk-preview==0.1.514"]
    lusid_drive_sdk_preview["lusid-drive-sdk-preview==0.1.617"]
    lusid_notifications_sdk_preview["lusid-notifications-sdk-preview==0.1.923"]
    lusid_scheduler_sdk_preview["lusid-scheduler-sdk-preview==0.0.829"]
    lusid_workflow_sdk_preview["lusid-workflow-sdk-preview==0.1.810"]
    lusidtools["lusidtools==1.0.14"]
    dve_lumipy_preview["dve-lumipy-preview==0.1.1075"]

```
sbatch-paramfile 0.1.1
A command line tool to create a sbatch file for a parameter file
Requires Python: >=3.6.0

# Create sbatch Array Job with the same size as a parameter file

This script creates a sbatch array job with the same size as a parameter file. The parameter file is a text file with one line per job. The script reads the parameter file and creates a sbatch array job with the same number of jobs as lines in the parameter file, with the option to specify the maximum number of jobs to run concurrently.

This is similar to `oarsub --array-param-file <file>` in OAR. But it won't launch the jobs automatically, you need to submit the job array manually.

## Usage

First make sure that your script has a logic that takes in the job index from slurm and reads the corresponding line from the parameter file. For example add this to your script:

```bash
args=$(sed -n ${SLURM_ARRAY_TASK_ID}p $1)
echo "Running with the following parameters:"
echo $args
IFS=' ' read -r -a array <<< $args
var1=${array[0]}
var2=${array[1]}
var3=${array[2]}

echo "var1: $var1"
echo "var2: $var2"
echo "var3: $var3"
```

Then run the tool to create the sbatch script from an existing sbatch file and a parameter file:

```bash
sbatch_paramfile <sbatch_file> <param_file> --max_run_jobs <max_run_jobs>
```

This will create a new sbatch file with the same name as the original sbatch file, but with `_paramfile` appended to the name. This new sbatch file will have the same number of jobs as lines in the parameter file, and it will add the `#SBATCH --array=1-<number_of_jobs>%<max_run_jobs>` line to the sbatch file.

Then submit the job array:

```bash
sbatch <output_sbatch_file> <param_file>
```

# Contact
- [Wissam Antoun](https://github.com/WissamAntoun/)
pcheck 0.1.5
A easy to use and blazingly fast proxy checker written in python
Requires Python: >=3.6

# Proxy Checker and Saver

## Overview

This Python script tests a list of proxies to determine which ones are working and saves the working proxies to an output file. It uses `aiohttp` for asynchronous HTTP requests, allowing it to efficiently check multiple proxies in parallel.

## Features

- Asynchronously checks a list of proxies.
- Tests proxies against a user-defined URL.
- Supports authentication in proxy URLs.
- Saves working proxies to a specified output file.
- Provides real-time progress updates on the command line.


## Requirements

- Python 3.7 or higher
- `pip` library

You can install the required library using pip:

```sh
pip install pcheck
```

## Usage
```sh
pcheck -i INPUT_FILE -o OUTPUT_FILE [-u TEST_URL] [-t TIMEOUT]
```


## Command-Line Arguments
```
    -i, --input: Path to the input file containing proxies. Each proxy should be on a new line.
    -o, --output: Path to the output file where working proxies will be saved.
    -u, --url: URL to test proxies against (default is http://httpbin.org/ip).
    -t, --timeout: Timeout for proxy requests in seconds (default is 5).
```

## Example

To test proxies listed in proxies.txt, save working proxies to working_proxies.txt, and test against http://example.com with a timeout of 10 seconds:

```sh
pcheck -i proxies.txt -o working_proxies.txt -u http://example.com -t 10
```

## Proxy Format

The script supports proxies in the following formats:

```
    username:password@host:port
    host:port:username:password
```

Make sure to provide proxies in one of these formats to ensure proper parsing.

## Output

The script writes the working proxies to the specified output file, with each proxy on a new line. It also displays real-time progress on the console, including the number of working and invalid proxies, checks per second, and the number of remaining proxies.

## License

This project is licensed under the MIT License. See the LICENSE file for details.
## Contact

For any questions or issues, please contact rootcode@duck.com or open an issue here.
neo-pusher 1.1.3
A package for Neo4j data ingestion using an AI agent.
Requires Python: >=3.10

# neo-pusher

`neo-pusher` is a Python package designed to facilitate the seamless transfer of data from CSV files to a Neo4j database. Leveraging the power of OpenAI's GPT models and the LangChain framework, `neo-pusher` automates the process of schema generation, data preprocessing, and data insertion into Neo4j, ensuring data consistency and integrity.

## Features

- **Automated Schema Generation**: Automatically generates a Neo4j schema based on the CSV file's headers.
- **Data Preprocessing**: Identifies and resolves inconsistencies in the data before pushing it to Neo4j.
- **Error Handling and Debugging**: The agent reruns and debugs code automatically if any errors are encountered during the process.
- **Multiple Dataset Support**: Capable of handling multiple datasets simultaneously, ensuring that all columns are properly represented in the database.

## Installation

To install `neo-pusher`, use pip:

```bash
pip install neo-pusher
```


## Usage

Here's an example of how to use `neo-pusher` to push data from a CSV file to a Neo4j database:

```python
from neo_pusher.agent import NeoAgent

# Initialize the NeoAgent with your OpenAI API key
agent = NeoAgent(apikey="your_openai_api_key",lang_chain_api_key="your_lang_chain_api_key")

# Define the parameters for your Neo4j database and CSV file
path = "path/to/your/csvfile.csv"
username = "neo4j_username"
password = "neo4j_password"
url = "bolt://localhost:7687"
data = "head of your csv data"

# Run the agent to push data to Neo4j
response = agent.run(path, username, password, url, data)
print(response)
```

### Parameters

- `apikey` (str): Your OpenAI API key.
- `langchain_api_key` (str): Your Langchain API key.
- `model` (str): The OpenAI model to use. Defaults to `"gpt-4o"`.
- `path` (str): The path to the CSV file.
- `username` (str): The username for the Neo4j database.
- `password` (str): The password for the Neo4j database.
- `url` (str): The URL of the Neo4j database.
- `data` (str): The head of the CSV file. Defaults to `None`.

### Return Value

- The `run` method returns a response from the LLM, including the results of the schema generation, data preprocessing, and data insertion into Neo4j.

## Example CSV Data

The following is an example of the CSV file headers that `neo-pusher` can process:

**Dataset 1:**

| order_details_id | order_id | pizza_id        | quantity |
|------------------|----------|-----------------|----------|
| 1                | 1        | hawaiian_m       | 1        |
| 2                | 2        | classic_dlx_m    | 1        |

**Dataset 2:**

| pizza_id | pizza_type_id | size | price |
|----------|---------------|------|-------|
| bbq_ckn_s | bbq_ckn       | S    | 12.75 |
| bbq_ckn_m | bbq_ckn       | M    | 16.75 |

## Notes

- The agent uses the `neo4j` Python package to connect to and push data into the Neo4j database.
- Before pushing data, the agent checks for any inconsistencies and cleans the data accordingly.

[Downloads](https://pepy.tech/project/neo-pusher)