semvec/pypi-packages huggingface dataset:
camera-service-api 1.5
Camera service grpc api
Requires Python: >=3.7

# Camera service grpc API 



## Install Camerm api 

### Install 

1. using pip install local package 
  
```bash
# Python12 
pip install camera-service-api==1.1.0


# Python7 
pip install camera-service-api==1.1.1


```


### Dependencies 

- grpcio     1.63.0
- protobuf   5.26.1


## Build by proto 

```shell

pip install   grpcio grpcio-tools protobuf

```


## API 



### Get API Instance  `create_camera_service_api`  

- host , camera server host , e.g.  `localhost` 
- port , camera server port , e.g.  `6000`


```python 

# host 
api = create_camera_service_api(host, port)


```
### Get All camera meta infos `get_camera_metas`

```python

def get_camera_metas(self) -> List[CameraMeta]:
    ...     

```

```python

metas = api.get_camera_metas()
for meta in metas:
    print(f"Camera modelName: {meta.modelName} - deviceVersion: {meta.deviceVersion}")
    print("get camera image serialNumber ", meta.serialNumber)
    print("get info ", meta.info)


```

### CameraMeta 

- cameraType , camera type , `GIGE` | `u3v` 
- serialNumber : camera serial number , 
- modelName  : model name 
- manufactureName : manufacture name 
- deviceVersion :  device version 
- userDefinedName : name defined by user 
- info : Map[string,string] , ext info 


### Get live image by serial number 

input camera serial number and return live image (jpg), bytes.
and if return `None` means the camera maybe offline. 

and using `try .. except` for catch `exception` 

```python

def get_image(self, sn: str) -> bytes:
    ...     

```

Example: 

```python

...
body = api.get_image(meta.serialNumber)
print(" body : ", len(body)  )

...

fopen = open('test.jpg', 'wb+')
fopen.write( body )
fopen.close()

...

```


## Example 

```python
import time

import grpc

from services.cameras.camera_service_api import create_camera_service_api


max_test = 100

def test_camera_api(host, port):
    #
    api = create_camera_service_api(host, port)
    metas = api.get_camera_metas()
    for meta in metas:
        print(f"Camera modelName: {meta.modelName} - deviceVersion: {meta.deviceVersion}")
        print("get camera image serialNumber ", meta.serialNumber)
        print("get info ", meta.info)

        t1 = time.time()
        try:
        
            for i in range( max_test ):
                body = api.get_image(meta.serialNumber)
                print(" body : ", i, len(body)  )

        except Exception as e:
            print( e) 

        t2 = time.time()
        tt = t2-t1
        avg = tt / max_test
        print( f" Try {max_test} times get image , using {tt} , avg {avg} ")

        # fopen = open('body.jpg'.encode('utf-8'), 'wb+')
        # fopen.write( body, )
        # fopen.close()

# protect the entry point
if __name__ == '__main__':
    print("GRPC Version : {} ".format(grpc.__version__))
    test_camera_api("127.0.0.1", 6000)



```
ComplexPy 0.0.1
A Python library for handling calculations of complex number.
Requires Python: >=3.6


# ComplexPy Library
ComplexPy is a Python library for storing and doing arithmetic with complex numbers.

This library allows you to perform elementary, trigonometric, logarithmic, and comparative operations with complex numbers.

## Functions

\-  ``toString``

\-  ``add`` / ``sum``

\-  ``sub`` / ``subtract`` / ``difference``

\-  ``mul`` / ``multiply`` / ``product`` / ``scale``

\-  ``div`` / ``divide`` / ``quotient``

\-  ``pow`` / ``exponentiate``

\-  ``sqrt`` / ``square_root``

\-  ``nroot`` / ``nth_root``

\-  ``abs`` / ``absolute_value`` / ``mod`` / ``modulus``

\-  ``conj`` / ``conjugate``

\-  ``arg`` / ``argument``

\-  ``ln`` / ``natural_log`` / ``natural_logarithm``

\-  ``log`` / ``logarithm`` / ``general_log``

\-  ``eq`` / ``equals``

\-  ``le`` / ``less`` / ``less_than``

\-  ``gr`` / ``greater`` / ``greater_than``

\-  ``leeq`` / ``less_than_or_equals``

\-  ``greq`` / ``greater_than_or_equals``

\-  ``sin`` / ``sine``

\-  ``cos`` / ``cosine``

\-  ``tan`` / ``tangent``

## Usage Examples
```py
from ComplexPy import *

number = complexNumber(3, 7)
number2 = complexNumber(8, 4)

print(number.toString()) # Will print "3 + 7 i"
print(number.add(number2).toString()) # Will print "11 + 11 i"
print(number.pow(complexNumber(3, 0)).toString()) # Will print "-414.00000000000006 - 154.0 i"
print(number.sine().toString()) # Will print "77.37850442046603 - 542.8288478055589 i"
print(number.sqrt().toString()) # Will print "2.3038850997677716 + 1.5191729832155236 i"
print(number.sqrt(1).toString()) # Will print "-2.3038850997677716 - 1.5191729832155234 i"
```
## Installation

You can install this library by running the command below in a command prompt or powershell terminal.

```bash
pip install ComplexPy
```

## Version history
### v1.0.0
\- Initial release.
unexart-lib 0.0.1
This is the simplest module created for educational purposes.
Requires Python: >=3.6
Keywords: Fibonacci bubblesort calculator

# Простая библиотека для учебных целей

Для того чтобы установить библиотеку и использовать в проекте необходимо ввести в терминал:

    pip install unexart_lib

## Что есть в этой библиотеке? ##

- Класс нахождения первых **n** чисел Фибоначчи
- Класс сортировки Пузырьком
- Класс простейшего калькулятора

### Последовательность Фибоначчи ###

Для нахождения первых **n** чисел последовательности необходимо создать экземпляр класса: 
	
	fib = fibonacci(n) # где n - кол-во чисел в последовательности

И применить метод нахождения последовательности:
	
	fib.make() - возвращает список из n чисел Фибоначчи

### Сортировка пузырьком ###

Для сортировки списка необходимо создать экземпляр класса: 
	
	bubble_sort = bubblesort(list) # где list - сортируемый список

И применить метод сортировки:
	
	bubble_sort.sort() - возвращает отсортированный список

### Калькулятор ###

Возможные операции:

- сумма **+**
- разность **-**
- произведение **\***
- частное **/**

Для вычислений необходимо создать экземпляр класса: 
	
	calc = calculator(num1, oper, num2) # где num1 и num2 - числа, а oper - символ операции

И применить метод вычисления ответа:
	
	calc.do() - возвращает ответ вычисления


----------


## Разработчик - UnexarT ##