semvec/pypi-packages huggingface dataset:
anne-fast 1.0.0
A library for lazy developer
Requires Python: >=3.10

# Anne Extension

Anne Extension là một thư viện Python hỗ trợ cho các bạn lazily.

## Mục lục

- [Giới thiệu](#giới-thiệu)
- [Cài đặt](#cài-đặt)
- [Sử dụng](#sử-dụng)
- [Các tính năng](#các-tính-năng)
- [Đóng góp](#đóng-góp)
- [Giấy phép](#giấy-phép)

## Giới thiệu

Anne Extension cung cấp các tính năng để giúp các bạn lazily.

## Cài đặt

Bạn có thể cài đặt thư viện này thông qua pip: pip install anne-extension

## Sử dụng

Để sử dụng thư viện, bạn cần import nó vào mỗi file Python của bạn:

```python
from anne_fast import AnneExtension
```

## Các tính năng

Tự khám phá các tính năng của thư viện nhé!

## Đóng góp

Bạn có thể đóng góp cho thư viện bằng cách góp , sửa lỗi, hoặc cải tiến thư viện. Gửi về Email: annehouman01@gmail.com

## Giấy phép

Thư viện này được xây dựng bởi AnneHouman.
facify 0.1
A simple and efficient tool for extracting faces from images using face detection Haar cascade.

# facify Package

  This is the package extracting faces form images.

## Installation

Install facify with pip

```bash
  pip install facify
```

    
## Usage/Examples

To see loaded image
```python
from facify import show
path = 'image_path'
show(path)
```
To extract faces from images
```python
from facify import detect
path = 'image_path'
detect(path)
```

The extracted faces stored in faces directory
crew-python-runner 0.2.1
Package to run crew.ai generated code in a docker instance
Requires Python: >=3.11

# crew-python-runner

Allows crew.ai agents to run python code in dockerized containers.

LLM code should not be run locally on your system, but we would like the ability of crew.ai agents to run Python code so they can see that it works.

`crew_python_runner` will take your agents code and run it in a Docker instance, so you can be sure that nothing bad will happen to your code.


## Installation

You will need Docker installed on your system

    pip install crew_python_runner

Note that crew_python_runner has a dependency on `crewai[tools]`, which has quite a lot of dependencies; this is likely not an issue if you have crewai already in your virtual environment.

 
 ## Setup

 On importing, a docker container will start running in the background. The first time this happens, it may have to download the docker image that it uses (python:3.11) so it is suggested you run the command

    python -c "import crew_python_runner"

Before using the library, as otherwise you may see a delay in usage. Alternatively, pull the image from docker yourself on the command line

    docker image pull python:3.11


## Usage

To use as a crew.ai tool:

    from crew_python_runner import runner

    # this is just an example - setup your agent however you like
    programmer = Agent(
        role='Senior Python Programmer',
        goal='Write simple, well crafted and bug-free Python code',
        backstory='You are a skilled Python programmer with a passion for writing working Python code',
        tools=[python_runner])


If you want to test it yourself:

    from crew_python_runner import runner
    result = runner.run_python('print("Hello, World!"))

This returns a class with 2 variables, *error_code*, an integer, and *output*, a string of the python output. In this case *error_code* will be 0 (meaning no error) and *output* will be *Hello, World!*.


## Future Enhancements

* Another tool giving coder agents the ability to *pip install* packages.
* The tool will auto-restart the docker instance if it falls over (which could be because of rogue code).
* The ability to log all code and results.
sl2pm 1.0.1
Tracking of nanoparticles, red blood cells, and microvessel walls with super-localization two-photon microscopy (SL2PM)
Requires Python: >=3.9

# SL2PM
A package for tracking particles, red blood cells (RBCs), and microvessel walls with super-localization from images recorded with two-photon microscopy (2PM). 

To get started with SL2PM, explore tutorials for tracking quantum dots, 
red blood cells, and capillaries. 
For example, if you are interested in measuring diameter of a capillary, made visible with fluorescently-labeled plasma (e.g. with FITC-dextran), see `tutorial/capillaries/track_capillary.ipynb` notebook.  

All tracking algorithms require calibration of the microscope's photomultiplier tubes (`tutorial/pmt_calibration/PMT_calibration.ipynb`) and, for tracking capillaries, calibration of the microscope's point-spread function (`tutorial/capillaries/PSF_calibration.ipynb`).

The data analysis in SL2PM is data-driven, i.e., you need to check if underlying assumptions of SL2PM analysis are satisfied 
in your data before you apply any function from SL2PM.
This is why we suggest using SL2PM with Jupyter notebooks, where you can explore your data step-by-step (following our examples) and tailor SL2PM analysis to your data, if needed. 

The documentation can be found at [https://sl2pm.readthedocs.io/en/latest/index.html](https://sl2pm.readthedocs.io/en/latest/index.html)

## Installation

For the users: install from the PyPi distribution

```
pip install sl2pm
```

For the developers: install from the source (optionally, from the new Conda environment):

```
git clone git@github.com:drkutuzov/sl2pm.git
cd sl2pm
conda create -n sl2pm python==3.10
conda activate sl2pm
pip install -e .
```

## Content
`src/sl2pm` contains the code for SL2PM.  
`docs/tutorial` contains folders with examples of data analysis with SL2PM. Each folder contains Jupyter notebooks tutorials and examples of experimental data (as numpy arrays).

`docs/tutorial/quantum_dots`: Tracking single quantum dots (QDs) in the brain parenchyma.  
`docs/tutorial/red_blood_cells`: Tracking single RBCs in a brain capillary.  
`docs/tutorial/capillaries`: Tracking diameter and center of a brain capillary and calibration of the microscope's PSF.  
`docs/tutorial/pmt_calibration`: Calibrating photomultiplier tubes (PMTs) for SL2PM.  
`docs/tutorial/bistable_bias`: Estimating parameters of bistable bias – artefact sometimes present in the output of PMTs.

## Usage
* Select a folder in `docs/tutorial` based on the data analysis you need.  
* Upload your data (e.g. as a numpy array) to the folder.  
* Make a copy of the Jupyter notebook tutorial or make a new one.  
* Use the notebook to analyse your data using the tutorial as a guide.
AlfenCharger 5.42
A Python library for controlling Alfen EV chargers
Requires Python: >=3.9

# Alfen Charge station Reader And Controller
A charge station reader and controller for **Alfen NG9xx** chargers 

This code was used in a home built Home Energy Management System (HEMS), to include an Alfen NG9xx charge station into a smart home. You can read more about it in my blog post: [How I built a HEMS with solar, a battery and a charge station (in Python)](https://medium.com/@harmvandenbrink/how-i-built-a-hems-with-solar-a-battery-and-a-charge-station-in-python-d5b51e60fd1c?source=friends_link&sk=f5e9302a02ea29065c3f677ecf1b8ed8)

# How to use the code
## Import the class and connect to an Alfen Chargestation

```python
from alfenchargestation import AlfenCharger
chargestation = AlfenCharger('ICU-00001', '192.168.1.X', 0, 20)

```

## Show a single value

```python
chargestation.readMeasurements()
print(chargestation.voltage_l1n)
```

## Control the charge station (single)

```python
# Sets the current to 10 amps
chargestation.changeCurrent(10)
```

## Control a set of chargers in a Smart Charging Network (SCN)

```python
# Set the current of the entire charging plaza to 42 amps
chargestation.changeCurrentSCN(42,42,42)
```

## Change charge using 1 or 3 phases

```python
# Set the number of phases to charge on
# !! Please verify that your car is capable of phase switching during charging !!
changeChargeNumberOfPhases(3)
```

# Disclaimer

The code within this repository comes with no guarantee, the use of this code is your responsibility.

I take NO responsibility and/or liability for how you choose to use any of the source code available here. By using any of the files available in this repository, you understand that you are AGREEING TO USE AT YOUR OWN RISK.
org-ds-cdk 0.1.12
DS Organization CDK Constructs

## Building and Publishing CDK Constructs to PyPi

Follow these steps to build your CDK constructs and publish them to PyPi:

1. **Ensure you have the necessary tools installed**

    You'll need Python, pip, setuptools, wheel, and twine. You can install these with pip:

    ```bash
    pip install --upgrade setuptools wheel twine
    ```

2. **Build your package**

    Navigate to the directory containing your `setup.py` file and run:

    ```bash
    python setup.py sdist bdist_wheel
    ```

    This will create a source archive (`.tar.gz`) and a wheel file (`.whl`) in a newly created `dist` directory.

3. **Check your package with twine**

    Before uploading, it's a good idea to check your package with twine:

    ```bash
    twine check dist/*
    ```

    This will check for common errors. If everything is okay, you can proceed to the next step.

4. **Upload your package to PyPi**

    You can upload your package using twine. Replace `dist/*` with the path to the files you want to upload:

    ```bash
    twine upload dist/*
    ```

    You'll be prompted for your PyPi username and password. If you have two-factor authentication enabled on PyPi, you'll need to generate an API token and use that instead of your password.

5. **Verify your package**

    Go to your PyPi account and verify that the package was uploaded successfully.


####
# API Gateway Construct

This package provides a construct for AWS Cloud Development Kit (CDK) to create an API Gateway with dynamic routes and methods based on a configuration.

## Features

- Creates an API Gateway with a custom name and description.
- Dynamically creates resources and methods based on a provided configuration.
- Supports Lambda integrations.

## Installation

To install this package, run the following command in your terminal:

```bash
pip install dscdk.apigateway
```

## Usage

```
from aws_cdk import App
from apigateway_construct import ApiGatewayStack

app = App()

lambda_stack = ...  # Your Lambda stack

config = {
    'routes': [
        {
            'path': '/myresource',
            'methods': ['GET'],
            'integration': 'lambda',
            'lambdaFunctionName': 'MyFunction',
        },
        # Add more routes as needed
    ],
}

ApiGatewayStack(app, "ApiGatewayStack", lambda_stack=lambda_stack, config=config)

app.synth()
```
netbits 0.0.3
Convert data into structured packets and make packet handling a breeze!
Requires Python: >=3.8

Net Bits
=========

Net Bits is a Python package that allows developers to easily convert data into structured packets which can be sent over a network. Additionally there are smart packet handling utilities which makes packet processing a breeze.

Installation
------------

Use the package manager `pip <https://pip.pypa.io/en/stable/>`_ to install netbits

.. code-block:: bash

    pip install netbits

Usage
-----

See the documentation at https://netbits.minersonline.uk/en/latest/

License
-------

Copyright (C) 2024 Samuel Hulme

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.

See `COPYING <https://github.com/ajh123/netbits/blob/main/COPYING>`_ and `COPYING.LESSER <https://github.com/ajh123/netbits/blob/main/COPYING.LESSER>`_ for more information.
smsapi-client 2.9.6
SmsAPI client

﻿# smsapi-python

[![Build Status](https://travis-ci.org/smsapi/smsapi-python-client.svg?branch=master)](https://travis-ci.org/smsapi/smsapi-python-client)
[![PyPI](https://img.shields.io/pypi/v/smsapi-client.svg)](https://pypi.python.org/pypi/smsapi-client)

Client for SMSAPI.

## COMPATIBILITY

Compatible with Python 2.7+, 3.+.

## REQUIREMENTS

requests

## INSTALLATION

If You have pip installed:

    sudo pip install smsapi-client

else You can install manually:

    git clone https://github.com/smsapi/smsapi-python-client.git

    cd smsapi-python

    python setup.py install

## Client instance

If You are smsapi.pl customer You should import

```python
from smsapi.client import SmsApiPlClient
```

else You need to use client for smsapi.com

```python
from smsapi.client import SmsApiComClient
```

## Credentials

#### Access Token

```python
from smsapi.client import SmsApiPlClient

token = "XXXX"

client = SmsApiPlClient(access_token=token)
```

## Examples

#### Send SMS

```python
from smsapi.client import SmsApiPlClient

token = "XXXX"

client = SmsApiPlClient(access_token=token)

send_results = client.sms.send(to="phone number", message="text message")

for result in send_results:
    print(result.id, result.points, result.error)
```

- **You can find more examples in "examples" directory in project files.**

## Error handling

```python
from smsapi.client import SmsApiPlClient
from smsapi.exception import SmsApiException

token = "XXXX"

client = SmsApiPlClient(access_token=token)

try:
    contact = client.sms.send(to="123123")
except SmsApiException as e:
    print(e.message, e.code)
```

## LICENSE

[Apache 2.0 License](https://github.com/smsapi/smsapi-python-client/blob/master/LICENSE)