semvec/pypi-packages huggingface dataset:
wifi-python 0.2
This is created for wifi testing purposes.


    WiFi_Python Package
    ===================

    WiFi_Python is a Python package designed for WiFi testing in IoT (Internet of Things) environments. It provides utilities and tools to facilitate WiFi connectivity testing, network analysis, and performance evaluation for IoT devices.

    Features
    --------

    - **Network Scanning**: Scan for nearby WiFi networks and retrieve essential information such as SSID, signal strength, and encryption type.
    - **Connectivity Testing**: Perform automated tests to check the stability and reliability of WiFi connections.
    - **Performance Evaluation**: Measure WiFi performance metrics such as throughput, latency, and packet loss under various network conditions.
    - **Integration with IoT Devices**: Seamlessly integrate WiFi_Python with IoT devices for automated testing and monitoring.

    Usage
    -----

    WiFi_Python can be easily integrated into your existing Python projects or used as a standalone tool for WiFi testing. Here's a basic example demonstrating how to scan for nearby WiFi networks:

    ```python
    from wifi_python import WiFiScanner

    # Initialize WiFi scanner
    scanner = WiFiScanner()

    # Scan for nearby WiFi networks
    networks = scanner.scan()

    # Print the list of detected networks
    for network in networks:
        print(network)
    ```

    For more detailed usage instructions and documentation, please visit the [GitHub repository](https://github.com/your_username/wifi_python).

    Requirements
    ------------

    - Python 3.x
    - Dependencies: None

    License
    -------

    WiFi_Python is licensed under the MIT License. See the [LICENSE](https://github.com/your_username/wifi_python/blob/main/LICENSE) file for details.
SnakeNest 0.3.0
Snake Nest
Requires Python: >=3.9
Keywords: codelithic, injection, spring

# SnakeNest

nest.yaml

```yaml
application:
  name: test
  spesa:
    - casa
    - sale
    - olio


snake:
  test:
    enable: pollo
```

Example 1

```python
from snakenest import *
from abc import ABC, abstractmethod


class WorkflowManager(ABC):
    @abstractmethod
    def test(self):
        pass


@Snake(condition={'key': 'snake.test.enable', 'value': 'salame'})
class Test1(WorkflowManager):

    def __init__(self):
        super().__init__()

    def test(self):
        print("Test1")


@Snake(condition={'key': 'snake.test.enable', 'value': 'pollo'})
class Test2(WorkflowManager):
    def __init__(self):
        super().__init__()

    def test(self):
        print("Test2")


class Check:
    @Poisoned()
    def __init__(self, wf: WorkflowManager):
        wf.test()


def print_hi(name):
    Check()


if __name__ == '__main__':
    Nest.initialize()
    print_hi('Clint')


```

Example 2

```python
from snakenest import *


@Snake(args={"val1": "10", "val2": "22"})
class Config:
    def __init__(self, val1, val2):
        self.val1 = val1
        self.val2 = val2

    def get_val1(self):
        return self.val1

    def get_val2(self):
        return self.val2


@Snake()
class MyCondition:
    def __init__(self):
        pass


@Snake()
class Test:
    @Poisoned()
    def __init__(self, config: Config):
        self.__config = config
        print(f'Test: {self.__config.__dict__}')

    def hello(self, name):
        return f"Test: Hello {name}"

    def getName(self):
        return "test_name"


@Snake(name='testName', args={"q": "10", "b": "${application.spesa:casa}"})
class Pollo:
    def __init__(self, q, b):
        self.q, self.b = q, b

    def hello(self, name):
        return f"Test_named: Hello {name}"

    def getName(self):
        return f'Pollo -> TestNamed: {self.q} - {self.b}'


class Test2:

    @Poisoned()
    def __init__(self, config: Config):
        self.__config = config
        print(f'Test2: {self.__config.__dict__}')

    @Poisoned()
    def getTestName(self, panico, name: Test):
        return name.hello(panico)

    @Poisoned(name='testName')
    def getTestName2(self, name):  # <-- tipo non definito ma injected
        return name.getName()


def print_hi(name):
    t2 = Test2()
    print(f'Hi, {name}, {t2.getTestName("sale")} {t2.getTestName2()} ')


if __name__ == '__main__':
    Nest.initialize()
    print_hi('PyCharm')
    # SnakeNest.clear()

```

SnakeBus message

```python
class MySubscriber(SnakeNotificationSubscriber):
    def handle_event(self, event_type, data=None):
        print(f'Received: {event_type} data: {data}')


class Service:
    def test(self):
        SnakesBus.publish('eventTest', {'something': 'test_data'})


SnakesBus.subscribe('eventTest', MySubscriber())
Service().test()
```
dismal 0.1.19b0
Demographic inference from the distribution of pairwise segregating sites

DISMaL: Demographic Inference under the Structured Coalescent using Maximum Likelihood
======================================================================================

``DISMaL`` is a Python package for inferring historical demographies
(specifically, population sizes, gene flow, and split times) from
sequence data. It is an implementation of the *Generalised
isolation-with-migration* (GIM) model of Costa & Wilkinson-Herbots
(2021). Please cite their paper if you use ``DISMaL`` in published work:

*Rui J. Costa, Hilde M. Wilkinson-Herbots (2021). Inference of gene flow
in the process of speciation: Efficient maximum-likelihood
implementation of a generalised isolation-with-migration model.
Theoretical Population Biology 140:1-15.
https://doi.org/10.1016/j.tpb.2021.03.001.*

Documentation is hosted on ReadTheDocs: https://dismal.readthedocs.io/en/latest/


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

Install latest full release with Pip: `pip install dismal`

Or the development version from GitHub: `pip install git+https://github.com/simonharnqvist/DISMaL.git#egg=dismal`
kickstart-flask-app 1.2.0
Generate a new Flask app project.
Requires Python: >=3.8

# kickstart-flask-app

This is a simple package to kickstart a new Flask app project.
It creates a new Flask project with a simple structure and some endpoints.

## Install

```bash
pip install kickstart-flask-app
```

## Usage

You could use this package in two ways:

### 1. Command line (recommended)

Type the following in your terminal

```bash
kickstart-flask-app
```

The above will propmt you to enter some data, press enter to use defaults.
This will create a new Flask project in the path you run the python interpreter

### 2. The Python interpreter

```py
from kickstart_flask_app import console

console()

```

Same as the command line, this will prompt you to enter some data, press enter to use defaults.

## Start the server

First, setup the virtual environment and set environment variables. (APP_ENV or FLASK_ENV to 'dev' or 'prod')

```bash
cd <your_project_name>
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
export FLASK_ENV=dev
```

Then start the server

```bash
python wsgi.py
```

The server should be running on `http://localhost:5000`

## Endpoints provided

`/` renders html template

`/api` returns json data