semvec/pypi-packages huggingface dataset:
multisocketing 1.3
A library that makes it easy to make multiplayer
Keywords: python, multiplayer, server, client, networking, host, sockets

# Multisocket
A library that handles all of the socket backend, While you can focus on making your application.

It's easy to set it up, Just make a Server (multisocket.server.Server) and some Clients (multisocket.client.Client),
Start the server, And connect the clients to the server.

You can give the client or the server a callback function, So that you can change their behaviour!

If you give the client a callback function, It will be called every frame and be given these arguments.

client - The client that called this function.
packets - All of the packets that the client recieved from the server, In a list.

This callback function can return a single packet, Or a list of them, And the client will send them to the server.


Similarly, If you give the server a callback function, It will also be called every frame, And get these arguments.

server - The server that called this function.
client - The client that the packets will be sent to.
packets - All of the packets that the server recieved from the client, In a list.

This callback function can also return packets to send to the client.


This is a simple script that uses multisocket to communicate between servers and clients:
```python
from multisocketing import clients, servers
from multisocketing import packets as packetClasses
import threading

def clientLoop(client, packets):
    print("packets from server:")
    print(packets)
    return packetClasses.Packet()

def serverLoop(server, client, packets):
    print("packets from client:")
    print(packets)

def setupServer():
    s = servers.Server(serverLoop)
    s.start()

def makeClient():
    c = clients.Client(clientLoop)
    c.connect()

thread = threading.Thread(target=setupServer)
thread.start()

thread = threading.Thread(target=makeClient)
thread.start()

makeClient()
```

Hope this library makes it easier for you to make socket-related applications!

(Seems like I had to re-build this 3 times just to fix the README...)
uz-ai 0.0.2
siz UzAi da sun'iy intelektlar yarata olasiz
Requires Python: >=3.8

# UzAI

**UzAI** - bu oddiy sun'iy intellekt (AI) tizimi bo'lib, foydalanuvchining kiritgan savollariga oldindan belgilangan javoblarni beradi. Ushbu kutubxona oddiy savol-javoblarni avtomatlashtirish uchun moslashuvchan va foydalanuvchi do'stona interfeysni taklif qiladi. Bu dasturchilar va yangi o'rganayotganlar uchun sun'iy intellekt algoritmlarini yaratishda asosiy vosita sifatida foydalanishga mo'ljallangan.

## O'rnatish

**UzAI** kutubxonasini PyPI orqali o'rnatish juda oson. Buning uchun siz terminalga yoki buyruq satriga quyidagi buyruqni kiriting:

```bash
pip install uzai
```

## foydalanish
```python
from uzai import UzAi

# AI obyektini yaratish
ai = UzAi()

# Foydalanuvchidan savol olish
savol = input('Savol kiriting: ')

# Savolni AI ga uzatish
ai.question(savol)

# Oldindan belgilangan javoblarni kiritish
ai.response([
    {'ques': 'salom', 'resp': 'Salom, qanday yordam bera olaman?'},
])

#tasodifiy javoblarni aytish
ai.random_response([
    {'ques': 'qalaysan', 'ran_resp': 'yaxshiman, o\'zingiz qalaysiz?|yaxshi, siz yaxshimisiz?'}
])

# Javobni chiqarish
ai.run()

```
edan 0.5.1
Python module to query the Smithsonian's internal Enterprise Digital Asset Network (EDAN).
Requires Python: >=3.11

# EDAN python

Basic python3 module to query the Smithsonian's Enterprise Digital Asset Network (EDAN). Requires Python 3.11 or higher.

## Installation

Install using pip:

```bash
pip install edan
```

Then, load the module in Python:

```python
import edan
```

You will need an ID and key, make the request in ServiceNow: https://edandoc.si.edu/more.html#auth

## metadata_search() - Search EDAN

The function `metadata_search()` takes these arguments:

 * `q` = Search terms
 * `fqs` = Python list of filter query parameters, for example:
   * `["online_media_type:\"Images\""]` - Select records with images
   * `["data_source:\"Smithsonian+Gardens\""]` - Limit results to a unit, SG in this case 
 * `edan_schema` = Filter results by specifying one of the valid EDAN schemas or record types (list at https://edandoc.si.edu/more.html#schemas)
 * `AppID` = Your AppID
 * `AppKey` = Your AppKey
 * `rows` = How many rows to return, max is 100, default is 10
 * `start` = Which row to start the results, default is 0

Example of setting your credentials and using `metadata_search()`:

```python
#EDAN creds
AppID = "APP_ID"
AppKey = "verylong_key"

#Search for images of orchids from Smithsonian Gardens
results = edan.metadata_search(q="orchids", fqs=["online_media_type:\"Images\"", "data_source:\"Smithsonian+Gardens\""],  AppID=AppID, AppKey=AppKey)

#Number of results available for this search
results['rowCount']

#To get the rows of results
results_rows = results['rows']
```

To get the list of units: 

```python
unit_search = edan.metadata_search(edan_schema="si-unit", AppID=AppID, AppKey=AppKey, rows=100)

# Create a list with unit title, url in EDAN, and description
units = []

#iterate through the results and save to list
for i in range(len(unit_search['rows'])):
    units.append([unit_search['rows'][i]['title'], unit_search['rows'][i]['url'], unit_search['rows'][i]['content']['description']])
```

## content_getcontent() - Get details of a single item using the item ID

The function `content_getcontent()` takes these arguments (must provide either `id` or `url`):

 * `id` = ID of the item
 * `url` = URL of the item
 * `AppID` = Your AppID
 * `AppKey` = Your AppKey

To see the details of an item:

```python
import json

item = edan.content_getcontent(url=results['rows'][0]['url'], AppID=AppID, AppKey=AppKey)

print(json.dumps(item, sort_keys = True, indent = 4))
```


## metadata_suggestions() - Returns a list of suggested content for a given search term

The function `metadata_suggestions()` takes these arguments:

 * `suggest` = Search terms
 * `AppID` = Your AppID
 * `AppKey` = Your AppKey
tb-wrapper 0.1.28
Wrapper for Zoe Project
Requires Python: >=3.8

# Tb_wrapper
## _Description_
This wrapper allows us to use the Python API client of Thingsboard.
## Installation

- TB wrapper requirements [tb_rest_client](https://pypi.org/project/tb-rest-client/)
- Thingsboard [Thingsboard](https://thingsboard.io/docs/reference/python-rest-client/)
```sh
pip install tb_wrapper
```
### Features
- Manage Entities such as Devices and Assets
- Access to thingsboard account using credentials stored into files
- Create Alarms 


## Build
- Requirements [twine](https://twine.readthedocs.io/en/stable/)
- Requirements [python](https://www.python.org/)
- Requirements [setuptools](https://pypi.org/project/setuptools/)


### Steps

First of all, change the version of the release to the latest version at the pyproject.toml file
```
[project]
name = "<my project name>"
version = "<my-version"
```
Create the dist directory used to upload the package into Pypi
```sh
python3 -m build
```

Upload the new version of the package using twine
```sh
twine upload dist/*
```
and use Username and Password based on API Token
mptool 0.1.3
Enumeration and sampling of minimal pathways in metabolic (sub)networks.
Requires Python: >=3
Keywords: metabolism, metabolic networks, metabolic pathways, minimal pathways, pathway analysis, pathway enumeration, pathway sampling, constraint-based modeling, metabolic modeling, systems biology

# Enumeration and sampling of minimal pathways in metabolic (sub)networks

Minimal pathways (MPs) are minimal sets of reactions that need to be active (have non-zero flux) in a metabolic (sub)network to satisfy all constraints on the network as a whole [1]. They can also be defined as the set of *support-minimal* flux patterns from elementary flux vectors (EFVs) [2].

An MP can be found by direct minimization of a mixed-integer linear program (MILP) or by iterative minimization of multiple linear programs (LPs). Enumeration of MPs is implemented using both of these approaches, in the iterative case by computing minimal cut sets (MCSs) in a separate binary integer program (BIP) [3]. For iterative minimzation, enumeration can be accelerated by using a graph defined by the known MPs to predict unknown MPs, or it can be randomized to allow random sampling of MPs in cases where complete enumeration is inconvenient or infeasible.

## Installation


The minimal requirements (`cobra`, `gurobipy`, `networkx`, `numpy`, and `pytest`) are installed automatically when `mptool` is installed through pip:
```
pip install mptool
```
The [Gurobi Optimizer](https://www.gurobi.com/) (tested with versions ≥9.0.1)) needs to be installed separately (free academic licenses).

## Citation

If you use `mptool` for a scientific publication please cite [our paper](https://www.biorxiv.org/content/10.1101/2020.07.31.230177v2) [1].

## References

[1] O. Øyås and J. Stelling. "Scalable metabolic pathway analysis". *biorXiv* (2020).

[2] S. Klamt et al. "From elementary flux modes to elementary flux vectors: Metabolic pathway analysis with arbitrary linear flux constraints". *PLoS Computational Biology* 13.4 (2017).

[3] H.S. Song et al. "Sequential computation of elementary modes and minimal cut sets in genome-scale metabolic networks using alternate integer linear programming". *Bioinformatics* 33.15 (2017).

[4] Z.A. King et al. "BiGG Models: A platform for integrating, standardizing, and sharing genome-scale models" *Nucleic Acids Research* 44.D1 (2016).

[5] A. Noronha et al. "The Virtual Metabolic Human database: integrating human and gut microbiome metabolism with nutrition and disease" *Nucleic Acids Research* 47.D1 (2018).
SshKeyDeploy 0.0.3
A CLI tool to create and deploy SSH keys

# SshKeyDeploy

A CLI tool to create and deploy SSH keys

# Usage

```bash
SshKeyDeploy [-h]
```

# Development

## Prerequisites

```bash
python -m pip install --upgrade build
```

```bash
python -m pip install --upgrade twine
```

## Build package

```bash
python -m build
```

## Upload package

```bash
python -m twine upload dist/*
```