semvec/pypi-packages huggingface dataset:
max-num 0.0.3
check max_number of arguments,list and dictionary
Requires Python: >=3.7


# Project description

# example:

       from max_num.max import Max
       ##check maximum number of undefined arguments
       
       check_max_value = Max.max_num(1,23,11,2,4) 
       print(check_max_value)
       ##check maximum number of a dictionary

       sample_dict = { "Esharat" : 200, 
                        "Masum": 300, 
                        "Liza": 100, 
                        "Mahreen": 50, 
                         } 
       check_max_dict_value = Max.max_num_dict(sample_dict) 
       for (Key,Value) in check_max_dict_value.items():
               print(f"{key} got highest score: {Value}")

       ##Check maximum number of a list

       sample_list = [12,23,34,12,4,7,9,19] 
       check_max_list_value = Max.max_num_list(sample_list) 
       print(f"The bigest number is {check_max_list_value}")
mapDisk 0.0.1
Hashable storage on disk
Requires Python: >=3.8

# MappingOnDisk
An effort to make a map system which can be stored on hard disk/SSDs and other non voletile media.

## Installation

pip install mapdisk

## Usage

from mapDisk import mapDisk

create the hashed map file object
    md = mapDisk.MapD("HashMapName.md","path/to/file")

"HashMapName.mpd" is the name of the database file, it is created if it does not already exists and read otherwise
path/to/file is "." by default


Adding key-value pairs

md.add("key","value")

key and value are converted to string and then stored for current implementation, returns the value stored for validating written data
the same function is used to overwrite the previous data/value


Reading value

md.read(str("key))

returns the value in string format, only catch is if the value contains \x00 at the end it will be trimmed off for current implementation as a temporary fix


Deleting value

md.delete(str(key))

deletes the key-value from datafile

md.shrink()

can be called to shrink datafile if some delete operations are performed, isn't called by default after delete operation.


md.close()

It should be called at the end of data operations to close file descriptors

The above operations return None if they fail for some reason, this can be used to check for failures
doc2req 0.9.0
apidoc to dataclasses and other useful utilities
Requires Python: >=3.9

# doc2req
doc2req is a library that simplfies the process of converting generated 
apidoc specifications into Python dataclasses (pydantic models) + other useful utilities.

## Key Features
1. convert apidoc specifications into pydantic models
2. generate request for each endpoint
3. generate apidoc specifications from source files dynamically

## Installation
```bash
pip install doc2req
```

## Usage

generate apidoc specifications from source files

```python
api : Api = from_src("src", clear_generated_node_modules=True)
```

access nodes
```python
api.points : List[Point]

# returns login point object by name
obj : Point | None = api["name::UserLoginLocal"] 

# returns login point object by url
obj : Point | None = api["url::/api/v3/user/login"]

# returns login point object by title
obj : Point | None = api["title::User Login"]

# returns first point object in group User
obj : Point | None = api["group::User"]
obj : Point | None = api["group::first::User"]

# returns last point object in group User
obj : Point | None = api["group::last::User"]

# returns all point objects in group User
obj : List[Point] | [] = api["group::all::User"]
```

point data structure
```python
name : str
type : typing.Literal["post", "get", "put", "delete", "patch"]
url : str
title : str
description : str = None
group : str
parameter : typing.List[Parameter] = Field(default_factory=list)
error : typing.List[Return] = None
version : str = None
filename : str = None
groupTitle : str = None
examples : typing.List[Example] = None
success : typing.List[Return] = None
```

create a request
```python
from doc2req.etc import UnpackableModel
class UserLogin(UnpackableModel):
    username : str
    password : str

    def unpack(self) -> dict:
        return {
            "username": self.username,
            "password": self.password
        }

test_login = UserLogin(username="xxxxx", password="xxxxx")

# create a request for login point
login :Point = api["name::UserLoginLocal"]
helper = login.prepReq(test_login)
result : RequestResult = helper.execute()

result.res : requests.Response

```