semvec/pypi-packages huggingface dataset:
GazeGenesis 0.0.4
A package including Computer Vision Pytorch projects.
Requires Python: >=3.9

# GazeGenesis
GazeGenesis: This repository is a playground for innovative computer vision projects, exploring cutting-edge algorithms, and pushing the boundaries of visual perception.🔭📸 #ComputerVision #AI #Innovation"

**The project is intended to leverage the cutting-edge Apple Silicon Architectures using MLX and PyTorch!**

[PyPI Link](https://pypi.org/project/GazeGenesis/)

**Install**
```zsh
python3 -m pip install GazeGenesis
```

<color style="color : orange">To receive the up-to-date package:</color>

```zsh

git clone https://github.com/sinamoghimi73/GazeGenesis.git
cd GazeGenesis/GazeGenesis
python3 -m pip install -e .
```
rdf-shacl-generator 1.0.8
Synthetic RDF graph generator based on SHACL constraints.

# Synthetic RDF graph generator based on SHACL constraints.

### rdf_shacl_generator is a Python package that can be used to generate RDF graphs based on SHACL constraints.

The following function can be used to generate RDF data:

__generate_rdf(file1, file2, number_of_entities)__
- file1 is a turtle file that contains SHACL shapes.
- file2 is a turtle file that will store the generated RDF entities
- number_of_entities is the number of RDF entities to be generated.

Link on PyPi: https://pypi.org/project/rdf-shacl-generator/

Link on GitHub: https://github.com/mveco/RDF_generator

Installation: 

```pip install rdf-shacl-generator```

After installation, this package can be used as a command line tool:

```rdfgen file1 file2 number_of_entities```

### Examples
Examples of SHACL Shapes based on Schema.org types can be found in the generated_examples\shape_examples directory in the GitHub repo,
along with generated RDF data samples for these Shapes (in the generated_examples\generated_rdf directory) .

### Remarks:
- A SHACL shape has to have a 'a sh:NodeShape' property and object in order to be recognized as a Node Shape.
- sh:severity is ignored because it has no useful info.
- SHACL Property Paths are not supported
- sh:datatype can have many different values, not all are recognized.
- sh:nodeKind is ignored
- The triples generated based on properties with a sh:minCount constraint can sometimes have a smaller value than the defined minimum count. This is because sometimes the generator generates the same triple multiple times.
prosto-sms 0.0.3
sms-prosto api wrapper written in python

# prosto-sms | API python wrapper

## TODO
- tests
------

## Install
```shell
python -m pip install prosto_sms
```
------

## Examples
### Auth by key and get profile data:
```python
import prosto_sms

api = prosto_sms.api.API(
    key="bd...5bb"
)

print(api.methods.get_profile())
```

### Auth by creds and get profile data:
```python
import prosto_sms

api = prosto_sms.api.API(
    email="me@chydo.dev",
    password="password"
)

print(api.methods.get_profile())
```
jaraco.zstd 1.1.1
zstd command
Requires Python: >=3.8

.. image:: https://img.shields.io/pypi/v/jaraco.zstd.svg
   :target: https://pypi.org/project/jaraco.zstd

.. image:: https://img.shields.io/pypi/pyversions/jaraco.zstd.svg

.. image:: https://github.com/jaraco/jaraco.zstd/actions/workflows/main.yml/badge.svg
   :target: https://github.com/jaraco/jaraco.zstd/actions?query=workflow%3A%22tests%22
   :alt: tests

.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json
    :target: https://github.com/astral-sh/ruff
    :alt: Ruff

.. .. image:: https://readthedocs.org/projects/PROJECT_RTD/badge/?version=latest
..    :target: https://PROJECT_RTD.readthedocs.io/en/latest/?badge=latest

.. image:: https://img.shields.io/badge/skeleton-2024-informational
   :target: https://blog.jaraco.com/skeleton

Extract files from a ``.tar.zstd``::

    python -m jaraco.zstd --extract filename.tar.zstd

Usage::

    python -m jaraco.zstd --help
    usage: zstd.py [-h] -e SOURCE [--out-dir OUT_DIR]

    options:
      -h, --help            show this help message and exit
      -e SOURCE, --extract SOURCE
      --out-dir OUT_DIR

This project can be retired if
`indygreg/python-zstandard#186 <https://github.com/indygreg/python-zstandard/issues/186>`_
is fixed.
beatprofiler 1.0.0
Cardiac functional analysis tool for in vitro models
Requires Python: >=3.8
Keywords: analysis, beatprofiler, calcium, cardiac, cardiomyocytes, contractility, eht, force, function, iPSC, monolayer, spheroid, tissue, tissue engineering

BeatProfiler is an all-in-one analysis software to extract functional metrics of _in vitro_ cardiac models. BeatProfiler enables processing of contractile and calcium videos and traces in a fast, reliable manner. To read more about BeatProfiler or download a GUI version, visit our [website](https://beatprofiler.github.io/) for tutorials, documentation, and a download link.
osscs 0.0.9
Open-source crypto-secure communication system
Requires Python: >=3.11

# OSSCS
This is small messanger base.

It is:
 - open source
 - crypto secure
 - peer to peer
 - end to end encrypted

# Installing

```bash
pip install osscs
```

# Usage

```python
import threading

from osscs.backend.client import MessageSender
from osscs.backend.server import MessageListener
from osscs.backend.core import SocketSender, SocketListener
from osscs.backend.storage import IPv4Address
from osscs.backend.models import Message, MessagePreparer, User
from osscs.cryptography.core import SignatureFabric, Encryptor, KeyLoader, Decryptor, SignatureVerifier
from osscs.types import BaseAddress


password = '12345'

addr = IPv4Address('127.0.0.1', 12012)

key_loader = KeyLoader()

decryptor = Decryptor(key_loader, key_loader.generate_private_key(), password)
encryptor = Encryptor(key_loader, decryptor.public_key())

signature_fabric = SignatureFabric(encryptor, decryptor)
signature_verifier = SignatureVerifier(encryptor, key_loader)


message_preparer = MessagePreparer(encryptor, decryptor, signature_fabric)
message_sender = MessageSender(SocketSender())
message_listener = MessageListener(SocketListener())

def on_message(message: Message, address: BaseAddress) -> None:
    user = 'Anonim'
    if message.signature and signature_verifier(message.signature):
        user = User(Encryptor(key_loader, key_loader.get_rsa_public_key(message.signature.public_key)))
    print(f'{user}[{address.data()}]: {decryptor.decrypt(message.text)}')

threading.Thread(
    target=message_listener.listen_on,
    args=[addr, on_message]
).start()

message = Message(text=b'Hello world')
message_preparer.encrypt(message, User(encryptor))
message_preparer.sign(message)

message_sender.send(
    message,
    addr
)

```

# Documentation in [DOC.py](https://github.com/ImCocos/ritatop/blob/master/DOC.py)
cosmosdb 0.1.12
Python SDK for Azure Cosmos DB NoSQL
Requires Python: >=3.10

# Cosmos DB

Python SDK for Azure Cosmos DB NoSQL

## About Cosmos DB

### Structure (DBs, containers, items)

- A CosmosDB *resource* can have multiple *DBs*
- A *DB* can have multiple *containers*
- A *container* can have multiple *items*

### Identifying

- Every item has a compulsory `id` field
- Every container defines a partition key, compulsory for all of it's items
  - The container's partition key field can be set to any string, including `/id`
- If the container's partition key is, e.g., `username`, a new item would be:
    ```json
    {
        "id": "<uuid>",
        "username": "<username>",
        // other optional fields
    }
    ```

### Querying

- Points reads can be done by giving `db, container, id, partition_key`
- Containers can be queried with SQL
  - Specifying a `partition_key` will limit the query to a partition

## Authorization

Both required fields can be obtained from the Azure Portal, within the Cosmos DB resource, Keys tab:

- `COSMOS_ENDPOINT` (URI in the portal): `https://<resource-name>.documents.azure.com:443/`
- `COSMOS_KEY` (PRIMARY KEY in the portal): `<random base64 string>`

### Environment (.env)

For convenience, you can set `os.environ["COSMOS_ENDPOINT"]` and `os.environ["COSMOS_KEY"]`. If you do, you can skip specifying them on every call.

E.g., create a `.env` file:

```bash
COSMOS_ENDPOINT="<COSMOS_ENDPOINT>"
COSMOS_KEY="<COSMOS_KEY>"
```

Then load it before importing

```python
from dotenv import load_dotenv
load_dotenv()
import cosmosdb as db

db.client() # just works!
```

## API

- Asynchronous (everything is a coroutine)
- Single calls or multiple using a same client:
  ```python
  # single call
  await db.list.dbs(url=COSMOS_ENDPOINT, key=COSMOS_KEY) # these aren't necessary with a .env file

  # multiple calls
  async with db.client(url=COSMOS_ENDPOINT, key=COSMOS_KEY) as client: # idem.
      await db.create.db("<db name>", client=client)
      dbs = await db.list.dbs(client=client)
  ```

### Functions
```python
cosmosdb
  create
    async def db(...)
    async def container(...)
    async def item(...)
  delete
    async def db(...)
    async def container(...)
    async def item(...)
  list
    async def dbs(...)
    async def containers(...)
    async def items(...)
  query
    async def read(...)
    async def sql(...)
```
blob-az 0.2.4
Async Python SDK for Azure Blob Storage (both block and append blobs)
Requires Python: >=3.10

# Azure Blob

## Installation

```bash
pip install blob-az
```

## Authorization

The required connection string can be obtained from the Azure Portal, within the Storage account, "Access keys" tab

### Environment (.env)

For convenience, you can set `os.environ["BLOB_CONN_STR"]`. If you do, you can skip specifying it on every call.

E.g., create a `.env` file:

```bash
BLOB_CONN_STR="<BLOB_CONN_STR>"
```

Then load it before importing

```python
from dotenv import load_dotenv
load_dotenv()
import blob_az as bz

bz.client() # just works!
```

## API

- Asynchronous (everything is a coroutine)
- Single calls or multiple using a same client:
  ```python
  # single call
  await bz.list.containers(conn_str=CONN_STR) # ain't necessary with a .env file

  # multiple calls
  async with bz.client() as client: # idem.
      await bz.container.create("<container-name>", client=client)
      cs = await bz.list.containers(client=client)
  ```

### Functions

```python
blob_az
    def client(...) -> BlobServiceClient
    list
        async def containers(...) -> list[dict]
        async def blobs(...) -> list[dict]
    container
        async def create(...)
        async def delete(...)
    blob
        async def upload(...)
        async def download(...) -> bytes
        def url(...) -> str # generate SAS url for blob
```
radyn-xtools 1.9.5
Python analysis tools for RADYN grid output

# radyn_xtools

**radyn_xtools** is a package with Python analysis routines for a grid of M dwarf flare models (Kowalski, Allred, & Carlsson, submitted to AAS journals on 2024 Feb 12) that were calculated with the RADYN code.  The `.fits` files (grid output) can be downloaded through Zenodo.  The dependencies (`numpy`, `plotly`, `matplotlib`, `ipympl`, `notebook`, `astropy`,`scipy`) are installed automatically below.

In a terminal window (assuming the user already has Anaconda):

`conda create --name your_env_name python=3.11`

`conda activate your_env_name`

`pip install radyn_xtools`

(in the previous command, either an underscore or hyphen b/w radyn and xtools will work!)

See the Jupyter notebook `radyn_xtools_Demo.ipynb` for a demonstration on how to use the analysis tools.  This notebook should be in the `your_env_name/site-packages/radyn_xtools/` folder.  To find it, start python and type:

`import radyn_xtools.radyn_xtools as radx`

`radx`

`radyn_xtools_Demo.html' shows what the notebook does without having to start up a Jupyter notebook session.

The only (optional) dependency that is not installed automatically is `ffmpeg`.  One of the cells in the notebook relies on this (but can be skipped).
To install this, activate your environment and then type:

`conda install -c conda-forge ffmpeg`