semvec/pypi-packages huggingface dataset:
start-manager 0.7.2
A python package manager based on pip and venv
Requires Python: >=3.10

# Start

> Full documentation visit [document](https://dragonz.us.kg/Start/).

A python package manager based on pip and venv, use `pyproject.toml` instead of `requirements.txt`


## install

Install from pypi

```shell
>>> pip install start-manager
```

Install from source

```shell
>>> pip install start@git+https://github.com/Dragon-GCS/Start
```

> `start` is a default alias in **powershell**, use **`Remove-Item alias:start -Force`** to remove alias before use `start`
>
> **Optional:** Add `Remove-Item alias:start -Force` in powershell profile
ester 0.1.0
A voice assistant package similar to Jarvis
Requires Python: >=3.6

## JARVIS AI

### Steps to run on your system.
Run following commands on terminal
- git clone https://github.com/Dhruv58/Jarvis-AI.git
- `conda create --name myenv`
- Activate Virtual Environment
  - Windows
    - conda activate myenv
  - Linux
    - source activate myenv
- pip install -r requirements.txt
- python main.py
include README.md
include LICENSE
pdmr 0.1.0
pdmr: Pandas Multiprocess Runner - A library for running functions on Pandas DataFrames with multiprocessing and checkpointing.
Requires Python: >=3.8

# pandas_multiprocess_runner

A library for running functions on Pandas DataFrames with multiprocessing and checkpointing, supporting both synchronous and asynchronous execution.

## Installation

```bash
pip install pdmr
```

## Usage
```python
from pdmr import PandasMultiprocessRunner
import pandas as pd

# Example usage with your inference logic:
def my_inference_function(index, prompt, response_a, response_b):
    # ... your inference logic using get_response and construct_prompt ...
    return {
        "result": inference_result,
        "other_data": "example"
    }

# Sample DataFrame (replace with your 'train' DataFrame)
data = {
    "Index": range(5),
    "prompt": ["prompt1", "prompt2", "prompt3", "prompt4", "prompt5"],
    "response_a": ["response_a1", "response_a2", "response_a3", "response_a4", "response_a5"],
    "response_b": ["response_b1", "response_b2", "response_b3", "response_b4", "response_b5"]
}
df = pd.DataFrame(data).set_index('Index')

runner = PandasMultiprocessRunner(
    my_inference_function,
    df,
    checkpoint_interval=2,
    output_dir="my_results",
    use_async=False  # or True for asynchronous
)
results_df = runner.run("prompt", "response_a", "response_b")

print(results_df)
```

```tree
pandas_multiprocess_runner/
├── pandas_multiprocess_runner/
│   ├── __init__.py
│   ├── core.py         # Core logic for processing and checkpointing
│   ├── utils.py        # Helper functions (e.g., for checkpointing)
│   └── exceptions.py   # Custom exception classes
├── tests/
│   ├── __init__.py
│   └── test_core.py    # Unit tests for core.py
├── setup.py           # Package metadata and installation
├── README.md          # Project description and usage instructions
├── requirements.txt   # Project dependencies
└── examples.py        # Example usage of the library
```
authinfo 0.0.4
Parse credentials in ~/.authinfo files, either plain text or GPG-encrypted.

########
authinfo
########


Introduction
############

This module provides access to authentication credentials stored in
``.authinfo`` files.

``.authinfo`` files are based on ``.netrc`` files, and allow a bit more
flexibility, but losing macro support.

They contain entries, formated as plain text, with ``key=${value}``
format fields.

``.authinfo`` files are multiprotocol and allow to do advanced matching.

``.authinfo`` files are typically encrypted using GPG, and this
library will invoke GPG to decrypt ``.authinfo.gpg`` files.


References:

- ``.netrc`` stuff:

  - ``import netrc``: https://docs.python.org/3/library/netrc.html
  - https://linux.die.net/man/5/netrc
  - https://www.gnu.org/software/inetutils/manual/html_node/The-_002enetrc-file.html

- ``.authinfo`` stuff:

  - https://www.emacswiki.org/emacs/GnusAuthinfo

  - https://www.gnu.org/software/emacs/manual/html_node/gnus/NNTP.html#index-nntp_002dauthinfo_002dfunction

  - emacs's `auth-source.el`, function `auth-source-netrc-parse`.


Usage
#####

TL;DR: Here's an example, and for now refer to the tests and code for more.

.. code:: python

   import authinfo

   ...

   entry = get_entry(
    machine='smtp.example.org',
   )
schemax-openapi 0.0.6
Useful OpenAPI parser for d42 universe
Requires Python: >=3.10

# OpenAPI Parser

Useful for d42 universe and schemax lib.


### Installation
```sh
python3 -m pip install schemax-openapi
```

### Usage

```python3
import yaml
import schemax_openapi
from schemax_openapi import SchemaData

from typing import List

# Also could be JSON OpenAPI file
with open('my_openapi.yaml') as schema_file:
    raw_schema = yaml.load(schema_file, yaml.FullLoader)
    
    parsed_data: List[SchemaData] = schemax_openapi.collect_schema_data(raw_schema)
    for item in parsed_data:
        print(item.path)
        print(item.response_schema_d42)
        ...
```

All the data is stored in `SchemaData` object, which has the following fields:
* http_method: HTTP method of the request.
* path: URL path of the request. 
* converted_path: URL path converted to the camel-case for usage in schemax generation. 
* args: Arguments of the request.
* queries: Query parameters of the request. Currently unsupported and always empty list: `[]`. 
* interface_method: Interface name for usage in schemax generation. 
* interface_method_humanized: Interface 'humanized' name for usage in schemax generation. 
* schema_prefix: Schema prefix name for usage in schemax generation. 
* schema_prefix_humanized: Schema prefix 'humanized' name for user in schemax generation. 
* response_schema: Normalized response schema (without $ref). 
* response_schema_d42: Converted to d42 response_schema. 
* request_schema: Normalized request schema (without $ref). 
* request_schema_d42: Converted to d42 request_schema. 
* tags: Tags of the request from OpenAPI schema.