semvec/pypi-packages huggingface dataset:
inventree-harmonized-system-codes 0.2.2
Support harmonized system codes against sales orders
Requires Python: >=3.9
Keywords: inventree, plugin

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![PyPI](https://img.shields.io/pypi/v/inventree-harmonized-system-codes)](https://pypi.org/project/inventree-harmonized-system-codes/)
![PEP](https://github.com/SchrodingersGat/inventree-harmonized-codes/actions/workflows/ci.yaml/badge.svg)

# Harmonized System Codes

An [InvenTree](https://inventree.org) plugin to support [harmonized system codes](https://en.wikipedia.org/wiki/Harmonized_System) (HS codes) against sales orders and shipments.

## Installation

### InvenTree Plugin Manager

The recommended method to install this plugin is via the InvenTree Plugin Manager.

### Command Line 

To install manually via the command line, run the following command:

```bash
pip install inventree-harmonized-system-codes
```

## Setup

### Activate the Plugin

... todo ...

### Run Migrations

... todo ...

## Configuration

... todo ...

## Usage

### Specifying Harmonized System Codes

To specify Harmonized System Codes (HS codes) for parts, navigate to the "Harmonized System Codes" section in the InvenTree admin interface. Here, you can create new HS codes and associate them with specific part categories. You can also specify customer-specific HS codes if needed.

When creating or editing a part, ensure that the part is assigned to a category that has an associated HS code.

### Customer Specific Codes

If desired, you can create customer-specific HS codes by selecting a customer when creating the HS code entry. This allows you to override the generic HS code for specific customers.

### Report Template Tags

The plugin provides a custom template tag to extract the Harmonized System Code associated with any part in a report.

To use the template tag, first load the `harmonized_codes` template library at the top of your report template:

```django
{% load harmonized_codes %}
```

Then, you can use the `harmonized_code` tag to retrieve the HS code for a given part. Note that the customer should also be supplied, in case there is a customer-specific HS code associated with the part.

For example, in the context of a SalesOrderShipment report:

```django

{% for allocation in allocations.all %}
    {% harmonized_code allocation.line.part customer=order.customer as hs_code %}
    <tr>
        <td>{{ allocation.line.part.full_name }}</td>
        <td>{% if hs_code %}{{ hs_code.code }}{% else %}N/A{% endif %}</td>
    </tr>
{% endfor %}
```
gamlset 0.1.2
Type집합을 만드는 라이브러리 입니다.
Requires Python: >=3.9

# GamlSet

Type집합을 만드는 라이브러리 입니다.

[![Python Version](https://img.shields.io/pypi/pyversions/gamlset.svg)](https://pypi.org/project/gamlset/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

## 설치

```bash
pip install gamlset
```

## 소개

유연하고 가독성 좋은 Type 생성 및 grouping을 돕습니다.

## 사용법

```python
# 기존 방식
class OldTypeSet:
    class OldTypeFeild_1:
        pass
    class OldTypeFeild_2:
        pass

class GamlType(GamlObj):
    pass

# GamlSet
class GamlTypeSet(GamlSet):
    GamlType_1 = GamlType # GamlTypeSet__GamlType1
    GamlType_2 = GamlType # GamlTypeSet__GamlType2
```

사용 예시들은 `examlple/`을 참고하세요.

## 개발 환경 설정

```bash
# 저장소 클론
git clone https://github.com/gamultong/gamlset.git
cd gamlset

# 개발 의존성 설치
pip install -e ".[dev]"

# 테스트 실행
python -m tests.run
```

## 빌드 및 배포

```bash
# 빌드
python setup.py sdist bdist_wheel

# PyPI 업로드
pip install twine
twine upload dist/*
```

## 라이선스

MIT License - 자세한 내용은 [LICENSE](LICENSE) 파일을 참조하세요.
TableGUI 1.1.3
A functional system to convert arrays into pixels using pygame.
Requires Python: >=3.9

# TableGUI: A game engine using arrays (now rendering in a screen)
### (DO NOT DOWNLOAD ANY VERSION BELOW 1.1.0)
A pygame-dependent arrays in lists system to convert the data inside the lists
inside of an array to convert to pixels in a screen.

![Demo usage of TableGUI](https://s6.imgcdn.dev/Yy7uQe.png)
## Installation
The easiest way to install TableGUI is through PyPi (pip)
```
pip install TableGUI
```

## Usage
I don't know. Try reading the documentation (probably coming soon)

## Upcoming features:
 - Text
 - Mouse detection
 - Documentation (coming probably after text)

## Version changelog
### 1.1.0: Fixes every issue.
### 1.1.1: Change some definitions of the table interpretation
### 1.1.2: Fixed uses with the PyPi page.
### 1.2.0: Made some more funcionality for rendering images.
fastapi-state 0.2.0
Simple state management utilities for FastAPI applications.
Requires Python: >=3.12

# FastAPI State

Simple state management utilities for FastAPI applications.

This package provides a decorator-based approach to define and inject
custom application state objects. It supports both synchronous and
asynchronous state initializers and ensures that state keys are unique
within a FastAPI application's lifecycle.

## Features

- Define application-wide state using decorators
- Support for both sync and async state initializers
- Works with both HTTP and WebSocket routes.

## Limitations

- When using a custom name with `@state('...')`, mypy may require a
  `# type: ignore[arg-type]` comment due to type narrowing limitations.

## Installation

```sh
# Install with pip
pip install fastapi-state
# Or add to your project
uv add fastapi-state
```

## Example

See more usage [examples](./examples).

```python
from contextlib import asynccontextmanager
from typing import Annotated, Any

import uvicorn
from fastapi import Body, Depends, FastAPI, HTTPException, status

from fastapi_state import state


def main() -> None:
    uvicorn.run(f'{__name__}:app')


type Database = dict[str, Any]


@state
def database() -> Database:
    return {}


@asynccontextmanager
async def lifespan(_app: FastAPI):  # noqa: ANN201
    state: dict = {}
    await database.inject(state)
    yield state


DatabaseDep = Annotated[Database, Depends(database.extract)]

app = FastAPI(lifespan=lifespan)


@app.put('/{key}')
async def put_item(key: str, value: Annotated[Any, Body()], db: DatabaseDep) -> Any:  # noqa: ANN401
    db[key] = value
    return value


@app.get('/{key}')
async def get_item(key: str, db: DatabaseDep) -> Any:  # noqa: ANN401
    if key in db:
        return db[key]

    raise HTTPException(status.HTTP_404_NOT_FOUND)
```

## License

This project is licensed under the [MIT License](./LICENSE).
apgard 0.2.1
SDK for safeguarding AI chatbots and minors
Requires Python: >=3.7

# Apgard SDK

Apgard is a privacy-preserving Python SDK designed to help AI companion companies build **safe, compliant, and personalized chat experiences**. It tracks user interactions across threads and provides real-time guidance to detect risks and intervene with care.

## Key Capabilities

- **Content Monitoring and Intervention** – Detects at-risk threads such as self-harm, suicidal ideation, or sexually explicit material, and provides guidance on proper intervention.

- **Break Tracker** – Tracks the duration of ongoing chat sessions and notifies when to take breaks. By default, breaks are triggered every three hours.

Apgard helps teams continue to **innovate safely**, ensuring that AI companions lead with care while meeting regulatory requirements such as California’s SB 243.

# API Key

Request access via this Google form: https://forms.gle/q6CekCHiDaEdL1CD8 

---

## Installation
```
pip install apgard
```

## Initialize client
By default, ApgardClient is synchronous. The SDK also has an asynchronous client. Reach out for more details.
```
from apgard import ApgardClient

client = ApgardClient(api_key="your-api-key")
```

## Get apgard user_id and start conversation
```
apgard_user_id = apgard_client.get_or_create_user_id(external_user_id='external_user_123') # Optional: pass your external user ID for mapping
conversation_id = apgard_client.moderation.start_conversation(apgard_user_id)
```

# Content Monitoring and Interventions
Call moderate_message() with user messages to detect high-risk content and guide the conversation:

```
result = client.moderation.moderate_message(
    user_id="user_123", # apgard user ID
    conversation_id="conversation_123", # apgard conversation ID
    content="I feel hopeless...", # message to analyze
    role="user"  # 'user' or 'assistant'
)

```
## Response Schema
The method returns a ChatIntervention object:

```
class ChatIntervention:
    message_id: str
    should_intervene: bool        # True if action is recommended
    severity: str                 # "low", "medium", "high", "critical"
    action: str                   # "allow", "guide_mental_reflection", "provide_crisis_hotline", "block"
    risk_type: List[str]          # e.g., ["self_harm", "sexual_content"]
    suggested_message: Optional[str] = None  # Guidance text for AI response
```
Example Usage
```
if result.should_intervene:
    # Use suggested_message to respond safely
    ai.send_message(result.suggested_message)
```

# Break Tracker
Call record_activity() whenever the user interacts with your chatbot:
```
break_status = client.breaks.record_activity(user_id="user_123") # apgard user ID

if break_status.break_due:
    # Display break reminder
    print(break_status.message)
else:
    # Continue chatbot interaction
    print("User can continue chatting")
```
## Response Schema
```
class BreakStatus:
    break_due: bool
    message: Optional[str] = None
````
data-depth 1.1.2.6
The package provides many procedures for calculating the depth of points in an empirical distribution for many notions of data depth
Requires Python: >=3.8

<h1 align="center">
<img src="./docs/_static/depth-logo.jpg" width="200">
</h1><br>

Data depth package
=================
___
Following the seminal idea of Tukey (1975), data depth is a function that measures how close an arbitrary point of the space is located to an implicitly defined center of a data cloud. Having undergone theoretical and computational developments, it is now employed in numerous applications. The **data-depth** library is a software directed to fuse experience of the applicant with recent achievements in the area of data depth. This library provides an implementation for exact and approximate computation of most reasonable and widely applied notions of **data-depth**.

- **Website:** https://data-depth.github.io
- **Source code:** https://github.com/data-depth/library
- **Contributing:** https://data-depth.github.io/multivariate/credits.html#contributors

___
Instalation:
---

data-depth can be directly installed using **pip**:

    pip install data-depth

Running GPU based depth requires CUDA availability, it can be installed using pytorch:
    
    pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
    pip install data-depth

For more information about CUDA version, see https://pytorch.org/get-started/locally/