semvec/pypi-packages huggingface dataset:
sator-core 0.0.17
Package with the core domain logic for Sator, an open-source vulnerability analysis application.
Requires Python: >=3.10
Keywords: package, sator, core, hexagonal, architecture

# sator-core

This package contains the core domain logic for Sator, an open-source vulnerability analysis application. 
It encapsulates business rules, entity definitions, and use cases, ensuring a clean separation from infrastructure and 
external dependencies. By isolating the domain logic, the architecture remains modular, testable, and adaptable to 
different interface implementations.


## Installation

```shell
$ pip install sator-core
```
cursor-multi 1.1.10
Cursor Multi
Requires Python: >=3.9

# cursor-multi

`cursor-multi` is the best way to work with Cursor on multiple Git repos at once. Set up your "sub-repos", for quick access to:

- Automatic syncing of Cursor rule .mcd files from the sub-repos
- Automatic syncing of your `.vscode` folder: `launch.json`, `tasks.json`, `settings.json`

## Installation

### Using `brew`

Run:
`brew tap montaguegabe/cursor-multi`
then
`brew install cursor-multi`

### Using `pipx` (MacOS, Linux, Windows):

- Install [pipx](https://github.com/pypa/pipx)
- Run `pipx install cursor-multi`

## Getting started

To get started, create a new directory that will house all your related repos and run:

```
multi init
```

Then paste in the URLs of all the repositories you want to use with Cursor. You can optionally specify descriptions of what they do, which will be used to create a new repo-directories.mdc Cursor rule.

It is recommended you also install the [VSCode/Cursor Extension]() that automatically keeps your project synced based on edits to files. To manually sync, you can run `multi sync`.

## Git operations

## TODO:

https://github.com/dawidd6/action-homebrew-bump-formula
imt-diodem 1.1.10
DIODEM -- A Diverse Inertial and Optical Dataset of kinEmatic chain Motion
Requires Python: >=3.10

![](imgs/pose1_noBG.png)

# DIODEM -- A <ins>D</ins>iverse <ins>I</ins>nertial and <ins>O</ins>ptical <ins>D</ins>ataset of Kin<ins>E</ins>matic chain <ins>M</ins>otion

This repository contains the source code of a Python Package (published on PyPI under `imt-diodem`) that allows for easy-access to the DIODEM dataset.

> **ℹ️ Installation:**
> 
> You can install with `pip install imt-diodem`.

> **ℹ️ Documentation:**
> 
> You can access the [Diodem Data Description](./docs/diodem.pdf) here.

The dataset files are hosted on Harvard Dataverse (https://doi.org/10.7910/DVN/SGJLZA). This Python Package then downloads the required dataset files from Dataverse on-demand.

## Quickstart
```python
import diodem

# concatenates 3 motions: the motion01, motion02 and motion03 
data = diodem.load_data(
    exp_id         = 1,
    motion_start   = 1,
    motion_stop    = 3,
    resample_to_hz = 100
)

print(data.keys())
# ['seg1', 'seg2', 'seg3', 'seg4', 'seg5']

print(data['seg1'].keys())
# ['imu_rigid', 'imu_nonrigid', 'marker1', 'marker2', 'marker3', 'marker4', 'quat']

print(data['seg1']['imu_rigid'].keys())
# ['acc', 'gyr', 'mag']
```
tadata-sdk 0.1.0
Tadata Python SDK
Requires Python: >=3.10
Keywords: llm, mcp, modelcontextprotocol, openapi, tadata

# Tadata Python SDK

The Tadata Python SDK provides an easy-to-use interface for deploying Model Context Protocol (MCP) servers from OpenAPI specifications.

## Installation

```bash
# With uv (recommended)
uv add tadata-sdk

# With pip
pip install tadata-sdk
```

## Quickstart

Deploy a Model Context Protocol (MCP) server with your OpenAPI specification:

```python
import tadata_sdk

# Deploy from a dictionary
result = tadata_sdk.deploy(
    openapi_spec={
        "openapi": "3.0.0",
        "info": {"title": "My API", "version": "1.0.0"},
        "paths": {"/hello": {"get": {"responses": {"200": {"description": "OK"}}}}},
    },
    api_key="TADATA_API_KEY",  # Required
    name="My MCP Deployment",  # Optional
    base_url="https://api.myservice.com",  # Required if no valid and absolute base url is found in the openapi spec
)

print(f"Deployed MCP server: {result.id}")
print(f"Created at: {result.created_at}")
```

## FastAPI Support

You can deploy FastAPI applications directly without manually extracting the OpenAPI specification:

```python
import tadata_sdk
from fastapi import FastAPI

# Create your FastAPI app
app = FastAPI(title="My API", version="1.0.0")

@app.get("/hello")
def hello():
    return {"message": "Hello World"}

# Deploy the FastAPI app directly
result = tadata_sdk.deploy(
    fastapi_app=app,
    api_key="TADATA_API_KEY",
    base_url="https://api.myservice.com",
    name="My FastAPI Deployment"
)

print(f"Deployed FastAPI app: {result.id}")
```

**Note:** FastAPI is not a required dependency. If you want to use FastAPI support, install it separately:

```bash
pip install fastapi
```

## Django Support

You can deploy Django REST Framework applications directly using drf-spectacular:

```python
import os
import tadata_sdk

# Set up Django environment
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')
import django
django.setup()

# Your Django settings should include:
# INSTALLED_APPS = [
#     # ... your apps
#     'rest_framework',
#     'drf_spectacular',
# ]
# REST_FRAMEWORK = {
#     'DEFAULT_SCHEMA_CLASS': 'drf_spectacular.openapi.AutoSchema',
# }

# Deploy using Django schema extraction
result = tadata_sdk.deploy(
    use_django=True,  # Extract schema from configured Django application
    api_key="TADATA_API_KEY",
    base_url="https://api.myservice.com",
    name="My Django Deployment"
)

print(f"Deployed Django app: {result.id}")
```

**Note:** Django, Django REST Framework, and drf-spectacular are not required dependencies. If you want to use Django support, install them separately:

```bash
pip install django djangorestframework drf-spectacular
```