semvec/pypi-packages huggingface dataset:
codewizard 1.0.2
A powerful assistant toolkit for developers
Requires Python: >=3.6

# CodeWizard

CodeWizard is a powerful assistant toolkit for developers. It provides various tools and utilities to streamline daily development tasks, improve productivity, and address common challenges.

## Features

- **Code Snippet Manager**: Store, retrieve, and manage reusable code snippets.
- **Automated Documentation Generator**: Generate documentation from code comments and docstrings.
- **Code Quality and Style Checker**: Analyze code for adherence to style guides and best practices.
- **Custom Commands and Extensions**: Support for custom commands to tailor the toolkit to specific needs.

## Installation

To install CodeWizard, use pip:

```
pip install codewizard
```

## Usage

### Snippets

#### Add a New Snippet
To add a new code snippet:
```
codewizard snippets add
```

You will be prompted to enter the snippet name, language, code, and tags.


#### List All Snippets

To list all stored code snippets:
```
codewizard snippets list
```

#### Find and Copy Snippet by Tag

To find snippets by a specific tag and optionally copy them to the clipboard:
```
codewizard snippets find --tag your-tag
```

You will be prompted to confirm if you want to copy the snippet to the clipboard.

## Documentation

### Generate Documentation

To generate documentation for a project based on its docstrings:
```
codewizard docs generate --path /path/to/your/project --output /path/to/output/docs
```

## Code Quality

### Check Code Quality for a Specific File

To check the code quality of a file and get a quality score:
```
codewizard quality check --file /path/to/your/file.py
```

## Help Command

To display all available commands under CodeWizard:
```
codewizard help
```
ircstates 0.13.0
IRC client session state parsing library
Requires Python: >=3.8

# ircstates

[![Build Status](https://travis-ci.org/jesopo/ircstates.svg?branch=master)](https://travis-ci.org/jesopo/ircstates)

## rationale

I wanted a bare-bones reference implementation of taking byte input, parsing it
into tokens and then managing an IRC client session state from it.

with this library, you can have client session state managed for you and put
additional arbitrary functionality on top of it.


## usage

### simple

```python
import ircstates

server = ircstates.Server("freenode")
lines  = server.recv(b":server 001 nick :hello world!\r\n")
lines += server.recv(b":nick JOIN #chan\r\n")
for line in lines:
    server.parse_tokens(line)

chan = server.channels["#chan"]
```

### socket to state

```python
import ircstates, irctokens, socket

NICK = "nickname"
CHAN = "#chan"
HOST = "127.0.0.1"
PORT = 6667

server  = ircstates.Server("freenode")
sock    = socket.socket()

sock.connect((HOST, PORT))
def _send(raw: str):
    sock.sendall(f"{raw}\r\n".encode("utf8"))

_send("USER test 0 * test")
_send(f"NICK {NICK}")

while True:
    recv_data  = sock.recv(1024)
    recv_lines = server.recv(recv_data)
    for line in recv_lines:
        server.parse_tokens(line)
        print(f"< {line.format()}")

        # user defined behaviors...
        if line.command == "PING":
            _send(f"PONG :{line.params[0]}")
```

### get a user's channels
```python
>>> server.users
{'nickname': User(nickname='nickname')}
>>> user = server.users["nickname"]
>>> user
User(nickname='nickname')
>>> user.channels
{'#chan'}
```

### get a channel's users
```python
>>> server.channels
{'#chan': Channel(name='#chan')}
>>> channel = server.channels["#chan"]
>>> channel
Channel(name='#chan')
>>> channel.users
{'jess': ChannelUser(#chan jess)}
```

### get a user's modes in channel
```python
>>> channel = server.channels["#chan"]
>>> channel_user = channel.users["nickname"]
>>> channel_user
ChannelUser(#chan jess +ov)
>>> channel_user.modes
{'o', 'v'}
```

## contact

Come say hi at `#irctokens` on irc.libera.chat
constructive-geometries 1.0
Simple tools to define world locations from a set of topological faces and set algebra
Requires Python: >=3.10

# Constructive Geometries - Python library

[![Documentation Status](https://readthedocs.org/projects/constructive-geometries/badge/?version=latest)](http://constructive-geometries.readthedocs.io/?badge=latest) [![Build Status](https://travis-ci.org/cmutel/constructive_geometries.svg?branch=master)](https://travis-ci.org/cmutel/constructive_geometries) [![Coverage Status](https://coveralls.io/repos/github/cmutel/constructive_geometries/badge.svg?branch=master)](https://coveralls.io/github/cmutel/constructive_geometries?branch=master)

Simple tools to define world locations from a set of topological faces and set algebra. For example, one could define a "rest of the world" which started from all countries, but excluded every country who name started with the letter "a".

[Documentation](http://constructive-geometries.readthedocs.io/?badge=latest) and [usage example](https://github.com/cmutel/constructive_geometries/blob/master/examples/Geomatching.ipynb).

Builds on top of [constructive geometries](https://github.com/cmutel/constructive_geometries).

Basic installation needs [wrapt](http://wrapt.readthedocs.io/en/latest/) and [country_converter](https://github.com/konstantinstadler/country_converter); GIS functions need [shapely](https://github.com/Toblerity/Shapely), and [fiona](https://github.com/Toblerity/Fiona).
imagehawk 0.0.9
A package for text to image search using embeddings


### _ImageHawk_


`This package generates embeddings for the given photos and saves them in the qdrant vector store`
`It also generates embeddings for your text query`
`It provides  a function to find an image based on its semantic similarityÂ to the text query`
`Currently, it supports the Qdrant Vector Store, but other stores will be added soon....`

#### _IMPORTANT_!

`Note: Before using the package , ensure your have follwing env variables "QDRANT_URL","QDRANT_API_KEY"`


#### _Usage_ 

```python
`Import`  
from imagehawk.Core import ImageHawk

`Class initialization`

imagehawk=ImageHawk(
    vectorstore="qdrant",
    collectionname="user:project"
)
`Image Embeddings  Generation and Saving in VectorStore`

imagehawk.generate_image_embeddings(
    new_collection=True , # OR False if collection already exists,
    imageurls=["https://samplelink/to/image1.jpg","https://samplelink/to/image2.jpg"]
)
`Text to Image Similarity Search`

search_result=imagehawk.search_similar_images(text="query text",result_limit=1)
print(search_result)

```


> Author:Junaid Bashir
> Note:Currently Qdrant is the only supported vectorstore (new stores coming soon)
tile-stitch 0.0.0
blends images using three different methods
Requires Python: >=3.6

# tile_stitch

(this was a university submission project)

Package implements methods for image dissection into tiles and their recomposition with three different stitching method.

The three implemented methods at the moment:
- min
- max
- multiband

min and max behaves similarly, when there is an overlap a max or min function is applied to the overlapping area, this way each color channel is compared on a pixel level and a max or min value is used per channel for the final image. 

In multiband mode the module uses this implementation https://github.com/cynricfu/multi-band-blending 




## Blending example
![result](./exampleimages/ll.png) |  ![result](./exampleimages/rr.png)
:-------------------------:|:-------------------------:
image 1             | image 2

![result](./exampleimages/min.png) |  ![result](./exampleimages/max.png) | ![result](./exampleimages/multiband.png)
:-------------------------:|:-------------------------:|:-------------------------:
minimum              | maximum          | multiband

# Installing requirements
- python >= 3
- numpy==2.1.0
- opencv-python==4.10.0.84

```
python3 -m pip install numpy opencv-python
```

# Installing tile_stitch package
from PyPI repoisitory
```
python3 -m pip install tile_stitch
```
or from this git pulled repo (requires setuptools)
```
python3 setup.py sdist bdist_wheel
python3 -m pip install . 
```
# Usage example

As a module 
```
python3 -m tile_stitch -s exampleimages/ll.png -f exampleimages/rr.png -o 100 -m multiband -r result.png
```

or source code, excerpt from main
```py
import tile_stitch
import cv2

img1 = cv2.imread('img1.png')
img2 = cv2.imread('img2.png')

overlap_w = 20 #20px overlap
bounds = tile_stitch.calculate_bounds([img1.shape[0],img1.shape[1],img1.shape[2]],[int(img1.shape[0]/2)+overlap_w,int(img1.shape[1]/2)+overlap_w,img1.shape[2]],[overlap_w,overlap_w,0])

tiles1 = tile_stitch.tile(img1,bounds) # tiles from img1 
tiles2 = tile_stitch.tile(img2,bounds) # tiles from img2

tiles = [tiles1[0], tiles2[1], tiles2[2], tiles1[3]] # combined into one array

result = tile_stitch.stitch(tiles, bounds, stitch_type='multiband') 

cv2.imwrite('result', result)

```