semvec/pypi-packages huggingface dataset:
loginween 0.0.1
LoginWeen
Requires Python: >=3.11

LoginWeen is a an app where you login/register with a halloween pumpkin carving as a password.

Live Demo (coming soon!): https://loginween.csd4ni3l.hu

# Install

## Download source & use uv
- Download source and change to it's directory
- copy `.env.example` to `.env` and update the settings as you like.
- `uv run loginween`

## Download source & use pip
- Download source and change to it's directory
- copy `.env.example` to `.env` and update the settings as you like.
- `pip3 install -r requirements.txt`
- `python3 loginween/app.py`

## Docker
- Coming soon!
arbitron 0.5.6
Multi-agent collaboration through pairwise comparisons
Requires Python: >=3.13

# Arbitron ⚖️

Arbitron is an agentic _pairwise_ comparison engine. Multiple jurors, each with unique value systems, evaluate items head-to-head and produce a set of pairwise comparisons that can be used to [derive item's ranks and weights](https://choix.lum.li/en/latest/api.html#processing-pairwise-comparisons).

- **Why pairwise?** It's easier to compare two items than to assign absolute scores.
- **Why multi-juror?** Different models with different perspectives (instructions) lead to more balanced, less biased outcomes.

## ✨ Features

- 🎯 **Arbitrary Sets**. Evaluate text, code, products, ideas
- 🤖 **Customizable Jurors**. Specify custom instructions, tools, providers
- 🛡️ **Bias Reduction**. Ensemble decision-making
- 🧩 **Remixable** — Join data with human labels and apply personalized heuristics

## 🚀 Quickstart

Running your first Arbitron "contest" is easy!

```bash
pip install arbitron
```

Setup your favorite LLM provider's API keys in the environment (e.g: `OPENAI_API_KEY`) and then run the following code.

```python
from arbitron import Competition, Item, Juror

items = [
    Item(id="arrival"),
    Item(id="interstellar"),
    Item(id="inception"),
]

jurors = [
    Juror(id="SciFi Purist", model="openai:gpt-5-nano"),
]

competition = Competition(
    id="sci-fi-soundtracks",
    description="Which movie has the better soundtrack?",
    jurors=jurors,
    items=items,
)

for comparison in competition.run():
    print(comparison)

print(f"Total cost: {competition.cost}")
```

## 🏛️ License

MIT License - see [LICENSE](LICENSE) file for details.

## 🙌 Acknowledgments

- [DeepGov](https://www.deepgov.org/) and their use of AI for Democratic Capital Allocation and Governance.
- [Daniel Kronovet](https://kronosapiens.github.io/) for his many writings on the power of pairwise comparisons.

---

*Margur veit það sem einn veit ekki.*
*Many know what one does not know.*
backbones 0.0.2
Backbone networks for computer vision research.
Requires Python: >=3.12
Keywords: perception, computer vision, deep learning, object detection, instance segmentation, semantic segmentation

# Backbones

A library of backbone architectures for neural networks, standardized for easy
use in research and development.

This library was created to solve the following problems.

1. Reduce boilerplate that comes with (efficiently) extracting features from
    some pre-trained network.

2. Implement compatability layers to port weights between different distributors
    of pre-trained weights.

3. Allow both training and inference of the sub-networks.

## Alternatives

If you are looking for a more general-purpose library, consider using
[Torchvision](https://pytorch.org/docs/stable/torchvision/index.html) or
[Timm](https://github.com/huggingface/timm). These libraries are geared towards
production, and are more feature-rich than this library.

## See Also

- [Pre-trained models](https://huggingface.co/khwstolle/backbones)
- [Backbones Documentation](https://gh.khws.io/backbones)
streamlit-sigmajs 0.1.1
Add your description here
Requires Python: >=3.7

# st-sigma

Streamlit component that allows you visualize interactive graphs using sigma.js.

## Installation instructions

Activate your uv venv, then run:

```sh
pip install -e .
```

To build your frontend code, run the following commands from the `st_sigma/frontend` directory:

```sh
npm install
npm run build
```

To run in development mode with hot-reloading, in the `st_sigma/frontend` directory, run:

```sh
npm install
npm run start
```

To start your streamlit app, in the `st_sigma` directory, run:

```sh
uv pip install streamlit neo4j
streamlit run example_app.py
```

## Usage instructions

```python
import streamlit as st
from st_sigma import st_sigmagraph, neo4jgraph_to_sigma

import neo4j
from neo4j import GraphDatabase

NEO4J_URI = "bolt://localhost:7677"
NEO4J_USER = "neo4j"
NEO4J_PASSWORD = "your_password"

def query_neo4j_graph(query):
    
    with GraphDatabase.driver(NEO4J_URI, auth=(NEO4J_USER, NEO4J_PASSWORD)) as driver:
        result = driver.execute_query( query, result_transformer_ = neo4j.Result.graph )
        
        return result


query = st.text_area(
    "Enter Cypher Query",
    value="MATCH (n)-[r]->(m) RETURN n, r, m LIMIT 4",
    height=100
)

st.subheader("Component with variable args")


height = st.slider("Graph Height", min_value=200, max_value=800, value=600, step=50)


if st.button("Visualize Graph"):
    try:
        with st.spinner("Querying Neo4j..."):
            result = query_neo4j_graph(query)
            result = neo4jgraph_to_sigma(result)
            
            if not result["nodes"]:
                st.warning("No nodes found in the query result.")
            else:
                st.success(f"Found {len(result['nodes'])} nodes and {len(result['relationships'])} relationships")
                
                st_sigmagraph(
                    graphData=result,
                    height=height,
                    key="neo4j_graph"
                )
    except Exception as e:
        st.error(f"Error: {str(e)}")
```