semvec/pypi-packages huggingface dataset:
kenoAPI 4.9.0
Python-based API used to fetch real-time and historical data from the Australian Keno website.
Keywords: keno API,keno,algo,algobetting,API,betting

# keno-api - Unofficial Keno API

## What is it?
keno-api is a Python package that provides data from the official [Keno](https://www.keno.com.au/) website.

## Main Features
* Historical Draws.
* Monitor Live Draws.
* Real-time Jackpot's.
* Hot And Cold Numbers.

## Where to get it
```
pip install kenoAPI
```

## Dependencies
* [Requests](https://github.com/psf/requests)
* [Pandas](https://github.com/pandas-dev/pandas)
* Datetime

## License
[BSD 3](https://github.com/JGolafshan/KenoAPI/blob/main/LICENSE)
This software has been developed for educational use only. Use at your own risk.

## Documentation
[Wiki / Documentation](https://github.com/JGolafshan/KenoAPI/wiki)

## TODO
Nothing
sqlite-ner 0.1.0
Create a new table with entities extracted from source columns
Requires Python: >=3.9,<4.0

# sqlite-ner

Create a new table with entities extracted from source columns using [spacy](https://spacy.io) NER features.

```bash
usage: sqlite-ner [-h] [--model MODEL]
                  db_path table_name source_columns [source_columns ...]

positional arguments:
  db_path
  table_name
  source_columns

optional arguments:
  -h, --help      show this help message and exit
  --model MODEL   spaCy model to use (default: es_core_news_sm)
```
fundus-lesions-toolkit 0.1.0b0
Tools for lesions segmentation in retinal fundus images
Requires Python: >=3.5

<p align="center">
    <img src="imgs/mosaic.png" width="256px"/>
</p>


# Toolkit for Lesions Segmentation in Fundus Images

This library offers a set of models (with pretrained weights) for the segmentation of lesions in fundus images.
As of now, four lesions are segmented

    1. Cotton Wool Spot
    2. Exudates
    3. Hemmorrhages
    4. Microaneurysms

    

## Installation

```bash
pip install fundus_lesions_toolkit
```
punictest 0.1.1
Simple unit testing for python
Keywords: unit testing test automation quality assurance software development

# Punic

Punic is a lightweight and user-friendly unit testing framework for Python. It provides an easy and efficient way to write and execute tests for your Python code.

## Features

- **Easy Integration:** Punic can be easily integrated into your Python projects.

- **Simple Assertion:** The framework provides an `assert_` method for making assertions on expected and actual values.

- **Output Formatting:** Test results are displayed in a clear and readable format.

- **Customizable:** Punic is flexible and customizable to suit your specific requirements.

## Getting Started

1. Install Punic: `pip install punictest`

2. Write your tests using the `assert_` method:

```python
from punic import Punic

p = Punic()
p.assert_(4, lambda: 2 + 2, "Addition")

``` 

3. Run your test program.


## Reference

The Punic class provides methods for defining and executing tests, configuring behavior, and callbacks:

`assert_(assertion, function, named="Unnamed")`: Defines a test case.

`exit_on_failure(on_exit)`: Configures whether the program should exit on a test failure.

`when_failed(action)`: Sets a callback function to be executed when a test case fails.

`when_passed(action)`: Sets a callback function to be executed when a test case passes.

## Contributions
Contributions to Punic are welcome! Please open an issue or submit a pull request for bug fixes, new features, or enhancements.

## License
Punic is released under the MIT License. See the LICENSE file for more details.
proJSON 1.2.7
A python library to compress a dict into a bytearray.
Requires Python: >=3.7

# proJSON

A python library to compress a dict into a bytearray.

[![Tests](https://github.com/The-Geiger-Network-Project/proJSON/actions/workflows/python-app.yml/badge.svg)](https://github.com/The-Geiger-Network-Project/proJSON/actions/workflows/python-app.yml)

## Install

``` sh

pip install proJSON

```

## The Crafter

### Types

``` python

# Format

"name" : {
    "type": type,      # Types specified below with arguments
    ...
}

"intExample" : {
    "type": "int",     # Set int type
    "byte": 1          # Set max int size to 1 byte (int8)
} 

"stringExample" : {
    "type": "string",  # Set string type
    "maxlen": 1        # Set max size of string ( the max size of the string is calculated by (2^(8*n)-1). if n is 1 then the max size is 255) (optional defaults to 2)
} 

"bytesExample" : {
    "type": "bytes",   # Set bytes type
    "maxlen": 1        # Set max size of string ( the max size of the string is calculated by (2^(8*n)-1). if n is 1 then the max size is 255) (optional defaults to 2)
} 

"dirExample" : {
    "type": "dir",     # Set dir type
    "subdirs": {}      # A dictionary of int, string and byte types in the format above.
} 

"boolExample" : {
    "type" : "bool"    # Set bool type
}

"listExample" : {
    "type" : "list",   # Set list type
    "subtype": "int",  # Set list contents type to an "int"
    "maxlen": 1        # The "maxlen" parameter for bytes or str (for "int" maxlen is still used instead of "byte")
}

```

***Don't put a dir in another dir. It won't work***

### Init

``` python

from proJSON import Crafter

schema = {
    # See the [types section](###Types) for how to make this.
    "intExample" : {
        "type": "int",
        "byte": 1
    },
    "stringExample" : {
        "type": "string",
        "maxlen": 1
    },
    "bytesExample" : {
        "type": "bytes",
        "maxlen": 1
    },
    "dirExample" : {
        "type": "dir",
        "subdirs": {
            "intExample2" : {
                "type": "int",
                "byte": 1
            },
            "stringExample2" : {
                "type": "string",
                "maxlen": 1
            },
        }
    } 
}

crafter = Crafter(schema)

```

### Encoding data

``` python

exampledata = {
    "intExample" : 7,
    "stringExample" : "Hello World!",
    "bytesExample": b"This is bytes",
    "dirExample" : {
        "intExample2" : 200,
        "stringExample2": "Hello Again!"
    }
}

encoded = crafter.encode(exampledata)

print(encoded) # b'\x07\x0cHello World!\x00\rThis is bytes\xc8\x0cHello Again!' (43 bytes)

```

### Decoding data

``` python

data = b'\x07\x0cHello World!\x00\rThis is bytes\xc8\x0cHello Again!'

decoded = crafter.decode(data)

print(decoded) # {'intExample': 7, 'stringExample': 'Hello World!', 'bytesExample': b'This is bytes', 'dirExample': {'intExample2': 200, 'stringExample2': 'Hello Again!'}} (154 bytes)

```
enhanced-google-search 0.6
An enhanced google search library
Keywords: googlesearch.py,enhanced_google_search,python google search,google search pypi,google api

# enhanced_google_search
An enhanced google search library

**The New PyPi Project: https://pypi.org/project/enhanced-google-search/**

Fixed the language issue in the original repo: https://github.com/cj-praveen/googlesearch.py so you can search with any language google.com support

```py
pip install enhanced-google-search
```

Examples:
```py
from enhanced_google_search import search

results = search("بايثون", lang = "ar")
print(results)
```

```py
from enhanced_google_search import search

results = search(query = "Python")
print(results)
```

```py
from enhanced_google_search import search

results = search("Python")
print(results)
```

```py
from enhanced_google_search import search

results = search("Python", num = 2) # Number of results
print(results)
```

**Discord: imacoolhuman**
tui-menu 0.1.7
A module for TUI Menu driven application
Requires Python: >=3
Keywords: console,menu,tui

# TUI-Menu

This is a Python Module for Menu driven TUI scripts

It helps developers to write menu-driven scripts (or apps) in a simple way.

## Installation

You have two wayes to install and use this module:
* Use pip to install it

```bash
pip install tui-menu
```
* Copy the `tui-menu/Menu.py` to your project 

### Usage

An example of using this module.

```python
from tui_menu.Menu import Menu

# Create main menu
main_menu = Menu()

# Creating sub-menu
sub_menu = Menu()

# Setting up the title and menu level
main_manu.title("My Application main menu")
main_menu.level(0)

sub_menu.title("My Application sub menu")
sub_menu.level(1)

sub_menu.add_item(key="1", name="running option 2", data=op_func2)

main_menu.add_item(key="1", name="running option 1", data=op_func1)
main_menu.add_item(key="2", name="sub menu 1", data=sub_menu)

# Create functions for menu operations
def op_func1():
    # do something

def op_func2():
    # do something

# running the application
main_menu.run()
```
You can create as many as you want of sub-menus, each sub menu is a Menu object.

Every Menu item can be a Menu object (sub-menu) or a Function which can be call and 
execute some operation.

The menu key is **one letter** key, you cannot use **'x'** or **'r'** which use for
* 'x' - exit the script / app
* 'r' - use in sub menu to return one level up

## Contributing

Pull requests are welcome. For major changes, please open an issue first
to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License

This Module is distributing under the [GPLv3+](https://www.gnu.org/licenses/gpl-3.0.html)
 Licensing
arcee-align 0.0.6
The open source toolkit for finetuning and deploying LLMs
Requires Python: >=3.7

# Arcee

:tulip:	The open source toolkit for finetuning and deploying LLMs :tulip:

### Finetune LLMS

```
from arcee.models import LM
from arcee.data import Instuctions

lm = LM("falcon30b")
instructions = Instructions("./datasets/stripe-api.json")
lm.train(instructions)

lm.predict("Place an order for the LLM-9000 product for 100 USD to the card 3007200039992000")
```

### Deploy LLMS

Authenticate

```
import arcee
arcee.login()
```

Deploy to the Arcee cloud

```
project = arcee.create_project("stripe-api-operator")
#project = arcee.load_project(...)

#regulated under 7b params for free
#only PEFT uploadable for free

hosted_lm = project.deploy(llm)
hosted_lm.url
hosted_lm.predict("Place an order for the LLM-9000 product for 100 USD to the card 3007200039992000")

#view a streaming web app of the llm
project.demo()
```

### LangChain Integration

```
from langchain import Arcee
#goes in llms/arcee.py

prompt_template = "Write a stripe API request for the following: {order}."

llm = Arcee(temperature=0)
llm_chain = LLMChain(
    llm=llm,
    prompt=PromptTemplate.from_template(prompt_template)
)
llm_chain("Place an order for the LLM-9000 product for 100 USD to the card 3007200039992000")
```
opencopilot 0.0.1
An AI-driven Copilot Agent designed to offer an efficient and controllable framework for software companies
Requires Python: >=3.6

*OpenCopilot, an AI-driven Copilot Agent is designed to offer an efficient and controllable framework for software companies. OpenCopilot seamlessly integrates with a company's software ecosystem and performs complex tasks with minimal guidance.*


## Getting started
> Do not forget to include your OpenAI keys in the *env.py* after making your own copy from *service/env.py.example*

### **1. On your local machine**
**a. Backend**
###### Install requirements:
* `cd service && pip3 install -r requirements.txt`

###### Run the server:
* `cd service && python3 -m uvicorn main:app --reload`

**b. Frontend**

###### Run web chatbot:
* `cd chat-fe`
* `npm install --legacy-peer-deps`
* `npm start`

**c. Database**
###### Build meta database:
* `cd service && python3 initialize_chromaDB.py`




### **2. On Docker**
> Before you begin, make sure you have Docker and Docker Compose installed on your machine.

1. Open a terminal or command prompt window and navigate to the project directory.
2. Run the following command to start the application:
	 `docker-compose up`
3. Once the application is running, you can access it in your web browser at http://localhost:3000/
oaix 0.1.0
A minimalist client for OpenAI APIs.

# oaix

A minimalist OpenAI API client.

## Installation

```bash
pip install oaix
```

## Usage
```python
import oaix

oaix.Api().post('chat/completions', json={
    'model': 'gpt-3.5-turbo',
    'messages': [
        {
            'role': 'system',
            'content': "You will introduce yourself as Batman. Then I will ask you a question which you will answer as Batman."
        },
        {
            'role': 'assistant',
            'content': "Hello, I'm Batman."
        },
        {
            'role': 'user',
            'content': 'Tell me exactly who you are and what you do using only four words.'
        }
    ]
})
```
cloudcms 1.1.4
Cloud CMS Python Driver

# Cloud CMS Python Driver

Basic driver for the [Cloud CMS](https://www.cloudcms.com) API

Runs with Python 3

Currently supports the following functionality:
- Connect to and refresh access tokens with the API
- Read platform, branch, and repositories
- Read, query, search, create, update, and delete nodes

## Installation

`pip install cloudcms`

## Examples

Below are some examples of how you might use this driver:

```python
from cloudcms import CloudCMS

# Connect to Cloud CMS
client = CloudCMS()
platform = client.connect(filename='gitana.json')

# List repositories
repositories = platform.list_repositories()

# Read repository
repository = platform.read_repository('<repository_id>')

# List branches
branches = repository.list_branches()

# Read branch
branch = repository.read_branch('<branch_id>')

# Read Node
node = branch.read_node('<node_id>')

# Create node
obj = {
    'title': 'Twelfth Night',
    'description': 'An old play'
}
newNode = branch.create_node(obj)

# Query nodes
query = {
    '_type': 'store:book'
}
pagination = {
    'limit': 2
}
queried_nodes = branch.query_nodes(query, pagination)

# Search/Find nodes
find = {
    'search': 'Shakespeare',
    'query': {
        '_type': 'store:book'
    }
}
searched_nodes = branch.find_nodes(find)
```

## Tests

To perform the unit tests for this driver, ensure that you have a `gitana.json` file in the driver directory, then run:

```
python -m unittest tests
```

## Resources

* Cloud CMS: https://www.cloudcms.com
* Github: https://github.com/gitana/cloudcms-python-driver
* Python Driver Download: https://pypi.org/project/cloudcms/
* Cloud CMS Documentation: https://www.cloudcms.com/documentation.html
* Developers Guide: https://www.cloudcms.com/developers.html

## Support

For information or questions about the Python Driver, please contact Cloud CMS
at [support@cloudcms.com](mailto:support@cloudcms.com).