semvec/pypi-packages huggingface dataset:
cross-bones 2.0.0
Cross-match By Offsetting Neighbouring Extracted Sources
Requires Python: >=3.9

# Cross-BONES 🏴‍☠️

[![Actions Status][actions-badge]][actions-link]
[![Documentation Status][rtd-badge]][rtd-link]

[![PyPI version][pypi-version]][pypi-link]
[![PyPI platforms][pypi-platforms]][pypi-link]

<!-- SPHINX-START -->

<!-- prettier-ignore-start -->
[actions-badge]:            https://github.com/flint-crew/cross-bones/workflows/CI/badge.svg
[actions-link]:             https://github.com/flint-crew/cross-bones/actions
[pypi-link]:                https://pypi.org/project/cross-bones/
[pypi-platforms]:           https://img.shields.io/pypi/pyversions/cross-bones
[pypi-version]:             https://img.shields.io/pypi/v/cross-bones
[rtd-badge]:                https://readthedocs.org/projects/cross-bones/badge/?version=latest
[rtd-link]:                 https://cross-bones.readthedocs.io/en/latest/?badge=latest

<!-- prettier-ignore-end -->

🏴‍☠️ Cross-match By Offsetting Neighbouring Extracted Sources 🏴‍☠️

Attempt to align catalogues of radio sources onto a self-consistent grid. It
implements a fairly simple iterative procedure that aims to reduce separations
between sources in common between pairs of catalogues.

## Installation

All dependencies can be installed via `pip`. We strongly recommend using [uv](https://docs.astral.sh/uv/).


### Install from GitHub (latest)

```bash
pip install git+https://github.com/flint-crew/cross-bones
```

### Install from PyPI release (stable)

```bash
pip install cross-bones
```

## Usage and documentation

### Command-line

Full documentation is hosted on [ReadTheDocs](https://cross-bones.readthedocs.io/en/latest/).

## Contributing

Contributions are welcome! Please open an issue to discuss ahead of opening a pull request.

### Dev tools

The dev tooling can be installed by using the `dev` option flags e.g.

```bash
git clone https://github.com/flint-crew/cross-bones.git
cd cross-bones
pip install -e .[dev]
pre-commit install
```
jl-metric 0.1.1
A Johnson-Lindenstrauss-based metric for dynamic graph generative model evaluation
Requires Python: >=3.7
Keywords: graph-learning, dynamic-graphs, generative-models

# Quality Measures for Dynamic Graph Generative Models

This repository contains the source code for our manuscript [Quality Measures for Dynamic Graph Generative Models](https://openreview.net/forum?id=8bjspmAMBk). Our JL-Metric provides a principled approach to evaluating generative models for continuous-time dynamic graphs (CTDGs). This repository contains both the metric implementation for practical use and the experimental code from our paper.

## Quick Start

To evaluate the quality of your generated dynamic graphs, follow the instructions below:

### Installation

```bash
pip install jl-metric
```

### Basic Usage

Our evaluator accepts graphs in the form of PyTorch Geometric [TemporalData](https://pytorch-geometric.readthedocs.io/en/latest/generated/torch_geometric.data.TemporalData.html#torch_geometric.data.TemporalData) objects. These should contain temporal interactions with source nodes (`src`), destination nodes (`dst`), timestamps (`t`), and optionally messages/features (`msg`).

```python
from jl_metric import JLEvaluator

# Initialize the evaluator
evaluator = JLEvaluator()

# Prepare your graphs as PyG TemporalData objects
# reference_graph = your ground truth or reference graph
# generated_graph = your model's generated graph

# Create input dictionary
input_dict = {
    'reference': reference_graph,
    'generated': generated_graph
}

# Evaluate and get results
result_dict = evaluator.eval(input_dict)
print(f"JL-Metric score: {result_dict['JL-Metric']}")
```

### Advanced Configuration

The evaluator accepts several optional parameters:

```python
evaluator = JLEvaluator(
    node_dim=100,     # Dimension for node embeddings
    graph_dim=100,    # Dimension for graph embeddings
    seed=42           # Random seed for reproducibility
)
```

## Paper Experiments

The experiments from our paper can be reproduced using the code in the `experiments/` directory:

```bash
# Install additional requirements for experiments
cd experiments
pip install -r requirements.txt

# Follow experiment-specific README
cat README.md
```

For details on our experimental methodology and to reproduce the results from our paper, please refer to the [experiments README](experiments/README.md).

## Citing Our Work

If you use JL-Metric in your research, please cite our paper:

```bibtex
@inproceedings{jl-metric,
    title={Quality Measures for Dynamic Graph Generative Models},
    author={Ryien Hosseini and Filippo Simini and Venkatram Vishwanath and Rebecca Willett and Henry Hoffmann},
    booktitle={The Thirteenth International Conference on Learning Representations},
    year={2025},
    url={https://openreview.net/forum?id=8bjspmAMBk}
}
```
sdk-api-adas 0.1.2
SDK para interactuar con la API ADAS protegida por AWS IAM
Requires Python: >=3.10

# SDK API ADAS

Este paquete es un SDK para interactuar con la API ADAS protegida por AWS IAM.

## Instalación

```bash
pip install sdk-api-adas
```

## Ejemplo de Uso

<!-- START EXAMPLE -->

```python
from sdk_api_adas.events import ApiEvents
from sdk_api_adas.utils.data_types import Parameters
from datetime import datetime, timedelta

if __name__ == "__main__":
    try:
        # Initialize the API client with your credentials
        api_client = ApiEvents(
            base_url="https://api.example.com/",
            aws_region="us-last-1",
            aws_access_key="your_access_key",
            aws_secret_key="your_access_key",
            aws_session_token="your_session_token",  # Optional
        )

        # Define the parameters for the API request
        parameters = Parameters(
            start=datetime.now() - timedelta(days=30),
            end=datetime.now(),
        )

        # Query: Get success events by state
        events_by_state = api_client.get_success_events_by_state(parameters)
        print("Events by state:", len(events_by_state))

        # Query: Get success events by driver
        parameters.driver_id = 123  # Set the driver ID
        events_by_driver = api_client.get_success_events_by_driver(parameters)
        print("Events by driver:", events_by_driver)

        # Query: Get success events by type
        parameters.event_type = "SPEEDING"  # Set the event type
        events_by_type = api_client.get_success_events_by_type(parameters)
        print("Events by type:", events_by_type)

        # Query: Get success events by bus
        parameters.bus_plate = "ABC123"  # Set the bus plate
        events_by_bus = api_client.get_success_events_by_bus(parameters)
        print("Events by bus:", events_by_bus)

    except Exception as e:
        print(f"An error occurred: {e}")
```

<!-- END EXAMPLE -->

## Licencia

MIT
IA22001UNO 0.1.0
Creación de una librería para resolver sistemas de ecuaciones lineales y ecuaciones no lineales
Requires Python: >=3.6

# IA22001UNO - Michelle Iglesias

LibrerÃ­a Python para resolver sistemas de ecuaciones lineales y no lineales.

## MÃ©todos Implementados para este examen corto nÂ°1 | MichelleIglesias

### MÃ©todos para sistemas lineales:
- EliminaciÃ³n de Gauss
- Gauss-Jordan
- Regla de Crammer
- DescomposiciÃ³n LU

### MÃ©todos para sistemas no lineales:
- Jacobi
- Gauss-Seidel
- BisecciÃ³n

## InstalaciÃ³n

```bash
pip install IA22001UNO
PA23013UNO 1.0.0
Librería para resolver sistemas de ecuaciones lineales y no lineales.
Requires Python: >=3.6

# PA23013UNO

Librería Python para resolver sistemas de ecuaciones lineales y no lineales.

## Descripción

Esta librería proporciona una colección de métodos numéricos para resolver sistemas de ecuaciones lineales y ecuaciones no lineales. Es ideal para estudiantes, investigadores y desarrolladores que necesiten herramientas matemáticas precisas y fáciles de usar.

## Métodos Implementados

### Sistemas Lineales
- **Eliminación de Gauss**: Resuelve sistemas de ecuaciones lineales usando eliminación hacia adelante y sustitución hacia atrás.
- **Gauss-Jordan**: Resuelve sistemas de ecuaciones lineales usando eliminación completa.
- **Regla de Cramer**: Resuelve sistemas de ecuaciones lineales usando determinantes.
- **Descomposición LU**: Resuelve sistemas de ecuaciones lineales usando factorización LU.
- **Método de Jacobi**: Resuelve sistemas de ecuaciones lineales usando iteraciones.
- **Método de Gauss-Seidel**: Resuelve sistemas de ecuaciones lineales usando iteraciones mejoradas.

### Ecuaciones No Lineales
- **Método de Bisección**: Encuentra raíces de ecuaciones no lineales dividiendo intervalos.

## Instalación

Puedes instalar la librería directamente desde PyPI:

```bash
pip install PA23013UNO
agentic-ai-vass-tools 0.4
provide SAP agentic AI tools
Requires Python: >=3.8

# agentic-ai-vass-tools

[![PyPI](https://img.shields.io/pypi/v/agentic-ai-vass-tools.svg)](https://pypi.org/project/agentic-ai-vass-tools/)
[![Tests](https://github.com/emadal95/agentic-ai-vass-tools/actions/workflows/test.yml/badge.svg)](https://github.com/emadal95/agentic-ai-vass-tools/actions/workflows/test.yml)
[![Changelog](https://img.shields.io/github/v/release/emadal95/agentic-ai-vass-tools?include_prereleases&label=changelog)](https://github.com/emadal95/agentic-ai-vass-tools/releases)
[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/emadal95/agentic-ai-vass-tools/blob/main/LICENSE)

provide SAP agentic AI tools

## Installation

Install this library using `pip`:
```bash
pip install agentic-ai-vass-tools
```
## Usage

Usage instructions go here.

## Development

To contribute to this library, first checkout the code. Then create a new virtual environment:
```bash
cd agentic-ai-vass-tools
python -m venv venv
source venv/bin/activate
```
Now install the dependencies and test dependencies:
```bash
python -m pip install -e '.[test]'
```
To run the tests:
```bash
python -m pytest
```
slock 0.0.3
Simplifying concurrency with granular lock management.
Requires Python: >=3.8

# slock

`slock` 是一个用于简化并发控制的 Python 库，提供基于键的粒度锁管理。它利用 `BaseKey` 类为不同的键创建独立的锁，确保线程安全。通过上下文管理器
`lock`，可以轻松地在多线程环境中控制资源的访问。

## 特性

- **基于键的粒度锁管理**：为不同的键创建独立锁，避免资源竞争。
- **线程安全**：确保在多线程环境下对资源的安全访问。
- **简单易用**：通过上下文管理器 `lock`，无需显式管理锁的获取和释放。
- **高效**：使用 `WeakValueDictionary` 来存储锁，避免内存泄漏。

## 安装

通过 `pip` 安装：

```bash
pip install slock
```

# 使用示例
## 简单示例
```python
from slock import BaseKey, lock


# 自定义键
class MyKey(BaseKey):
    """
    使用类和初始化时的 key 作为锁的唯一标识。
    当类和 key 完全相同时，线程会等待锁释放才能继续执行。
    类名和 key 的组合用于生成锁的标识符，不涉及引用关系，主要用于区分不同资源。
    """
    pass


# 创建一个键对象
my_key = MyKey(key="resource_1") #key 用于唯一标识一个资源。它是锁的最小单元，可以为空，默认情况下 key 为 None，此时锁的标识由类名生成。

# 使用锁来同步访问资源
with lock(my_key):
    # 你的并发操作代码
    print("Accessing resource_1 safely")
```

## 使用 slock 解决竞争
```python
from slock import BaseKey, lock
import threading


# 定义资源键
class ResourceKey(BaseKey):
    """
    使用类和初始化时的 key 作为锁的唯一标识。
    当类和 key 完全相同时，线程会等待锁释放才能继续执行。
    类名和 key 的组合用于生成锁的标识符，不涉及引用关系，主要用于区分不同资源。
    """
    pass

# 共享资源
shared_resource = 0


# 模拟线程安全的资源增加
def increment():
    global shared_resource
    with lock(ResourceKey("shared_resource")):  # 创建资源键 使用锁避免竞争
        shared_resource += 1

# 存储线程
threads: list[threading] = []

# 创建并启动多个线程
for i in range(10000):
    thread: threading = threading.Thread(target=increment)
    thread.start()
    threads.append(thread)

# 等待所有线程完成
for thread in threads:
    thread.join()

# 输出最终的结果
print(f"最终共享资源的值：{shared_resource}")
```
# 使用async
```python
from slock.async_lock import lock, get_lock
```