semvec/pypi-packages huggingface dataset:
propertiesLiCl 0.1.0
A package for aqueous LiCl properties calculations
Requires Python: >=3.6

# Package Description

This file contains property data for aqueous sodium hydroxide solutions.

### Installation and Unsage

```
pip install propertiesNaOH
```

```python
# Import
import propertiesNaOH as NaOH

# Example Usage
p = 100000 # [Pa]
x = 0.4    # [%]  = [kgNaOH / kgSolution]
t_sat = NaOH.saturation_temperature(p, x)
print(t_sat)
```

### Available Property-Functions

| Function                        | Parameter 1           | Parameter 2           | Parameter 3    | Return Unit   |
|----------------------------------|-----------------------|-----------------------|----------------|---------------|
| saturation_temperature(P, x1)    | P (Pa)                | x (kgNaOH/kgSolution) | -              | °C            |
| enthalpy(x, T)                   | x (kgNaOH/kgSolution) | T (°C)                | -              | kJ/kg         |
| saturation_pressure(x, T)        | x (kgNaOH/kgSolution) | T (°C)                | -              | Pa            |
| dhdx(x, T)                       | x (kgNaOH/kgSolution) | T (°C)                | -              | kJ/kg         |
| dhdT(x, T)                       | x (kgNaOH/kgSolution) | T (°C)                | -              | kJ/kg·K       |
| specific_heat_capacity(x, T)     | x (kgNaOH/kgSolution) | T (°C)                | -              | kJ/kg·K       |
| density(x, T)                    | x (kgNaOH/kgSolution) | T (°C)                | -              | kg/m³         |
| dynamic_viscosity(x, T)          | x (kgNaOH/kgSolution) | T (°C)                | -              | Pa·s          |
| thermal_conductivity(x, T, p)    | x (kgNaOH/kgSolution) | T (°C)                | p (Pa)         | W/m·K         |


### Available Utilities


| Function                 | Description                  | Boolean Options + Defaults                              |
|--------------------------|------------------------------|---------------------------------------------------------|
| pTDiagram()              | shows pT-Diagram             | log=True, invT=True                                     |
|                          |                              | editablePlot=False, show_percentages=True               |
| crystallization_curve()  | shows crystallization curve  | return_data=False (if True, only data returned, no plot)|
murnitur 1.1.13
Murnitur empowers AI teams to seamlessly test, evaluate, deploy, monitor, and safeguard GenAI applications continuously.
Requires Python: >=3.7.1

# Murnix-Trace.ai

Murnix-Trace is a powerful LLM (Logs, Metrics, and Tracing) monitoring package designed to provide comprehensive insights into the performance and behavior of your applications and systems. Leveraging advanced tracing and monitoring capabilities, Murnix-Trace.ai empowers developers and SREs to detect, diagnose, and resolve issues quickly, ensuring optimal performance and reliability.

## Features

- Real-time tracing: Gain visibility into the flow of requests and transactions across your distributed systems in real-time.
- Customizable metrics: Collect and analyze custom metrics to monitor key performance indicators (KPIs) and business metrics.
- Log aggregation: Aggregate and centralize logs from multiple sources for easy troubleshooting and analysis.
- Seamless integration: Integrate seamlessly with your existing infrastructure and applications using open standards and APIs.
- Scalable and reliable: Built for scalability and reliability, Murnix-Trace.ai can handle high volumes of data without compromising performance.
albatross-sdk 0.1.3
Python SDK for interacting with the Albatross API
Requires Python: >=3.12

# Albatross Python SDK

[![Pyright Type Checking](https://github.com/albatross-core/py-sdk/actions/workflows/ci.yml/badge.svg)](https://github.com/albatross-core/py-sdk/actions/workflows/ci.yml)

published: https://pypi.org/project/albatross-sdk/

A Python SDK for interacting with the Albatross API. This SDK provides a simple and intuitive way to manage categories and units in your Albatross instance.

## Features

- Easy authentication using ECDSA keypairs
- Category management (create, update, list)
- Unit operations
- CSV data import support

## Installation

```bash
pip install albatross-sdk
```

## Prerequisites

- Python 3.12 or higher
- An Albatross instance and credentials
- ECDSA keypair for authentication

## Authentication

### Generating a Keypair

Generate an [ECDSA](https://en.wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm) keypair using OpenSSL:

```bash
openssl ecparam -genkey -name prime256v1 -noout -out ecdsa_private_key.pem
openssl ec -in ecdsa_private_key.pem -pubout -out ecdsa_public_key.pem
```

## Quick Start

```python
from albatross_sdk.lib import AlbatrossSDK, CategoryData

# Initialize the client
private_key = AlbatrossSDK.load_private_key("path/to/your/private_key.pem")
instance_id = "your-instance-id"
client = AlbatrossSDK(
    instance=instance_id,
    private_key=private_key,
    base_url="https://your-albatross-instance.com"  # Optional
)

# Check API version
version = client.get_api_version()
print(f"Connected to Albatross API version: {version}")

# Create a category
category_data: CategoryData = {
    "unit": "user",
    "values": {
        "country_code": "US",
        "grade_level": 3,
        "user": "user-uuid"
    }
}

response = client.put_categories([category_data])
print(f"Category created: {response}")
```

## Working with Categories

### Single Category Operations

```python
# Define a category
user_category: CategoryData = {
    "unit": "user",
    "values": {
        "country_code": "AT",
        "grade_level": 2,
        "user": "39e23058-b7da-4a79-b464-5b67b579a433"
    }
}

# Create or update the category
result = client.put_categories([user_category])
```

### Bulk Import from CSV

```python
# Import categories from a CSV file
client.put_categories_csv("path/to/categories.csv", "user")
```

## Configuration Examples

```python
# Multiple instance configuration
instances = {
    "prod": "c094dea1-8b01-11ef-9882-068cf85ff8bb",
    "staging": "22a06113-8b04-11ef-ade1-42010aac0020",
    "dev": "96757573-827b-11ef-9882-068cf85ff8bb",
}

# Initialize client with specific instance
client = AlbatrossSDK(
    instance=instances["prod"],
    private_key=private_key,
    base_url="https://api.albatross.com"
)
```

## Development

### Running Tests

```bash
python -m pytest
```

### Type Checking

```bash
pyright .
```

## Related Resources

- [Go SDK Sample Code](https://gist.github.com/johnb8005/878da37315920b8538a25f651ba0db0f)
- [API Documentation](https://albatross-core.github.io/publicApiSpec/#/)
propertiesCaCl2 0.1.2
A package for aqueous CaCl2 properties calculations
Requires Python: >=3.6

# Package Description

This file contains property data for aqueous sodium hydroxide solutions.

### Installation and Unsage

```
pip install propertiesNaOH
```

```python
# Import
import propertiesNaOH as NaOH

# Example Usage
p = 100000 # [Pa]
x = 0.4    # [%]  = [kgNaOH / kgSolution]
t_sat = NaOH.saturation_temperature(p, x)
print(t_sat)
```

### Available Property-Functions

| Function                        | Parameter 1           | Parameter 2           | Parameter 3    | Return Unit   |
|----------------------------------|-----------------------|-----------------------|----------------|---------------|
| saturation_temperature(P, x1)    | P (Pa)                | x (kgNaOH/kgSolution) | -              | °C            |
| enthalpy(x, T)                   | x (kgNaOH/kgSolution) | T (°C)                | -              | kJ/kg         |
| saturation_pressure(x, T)        | x (kgNaOH/kgSolution) | T (°C)                | -              | Pa            |
| dhdx(x, T)                       | x (kgNaOH/kgSolution) | T (°C)                | -              | kJ/kg         |
| dhdT(x, T)                       | x (kgNaOH/kgSolution) | T (°C)                | -              | kJ/kg·K       |
| specific_heat_capacity(x, T)     | x (kgNaOH/kgSolution) | T (°C)                | -              | kJ/kg·K       |
| density(x, T)                    | x (kgNaOH/kgSolution) | T (°C)                | -              | kg/m³         |
| dynamic_viscosity(x, T)          | x (kgNaOH/kgSolution) | T (°C)                | -              | Pa·s          |
| thermal_conductivity(x, T, p)    | x (kgNaOH/kgSolution) | T (°C)                | p (Pa)         | W/m·K         |


### Available Utilities


| Function                 | Description                  | Boolean Options + Defaults                              |
|--------------------------|------------------------------|---------------------------------------------------------|
| pTDiagram()              | shows pT-Diagram             | log=True, invT=True                                     |
|                          |                              | editablePlot=False, show_percentages=True               |
| crystallization_curve()  | shows crystallization curve  | return_data=False (if True, only data returned, no plot)|
pipeteer 1.0.5
Simple, explicit durable execution framework on top of ZeroMQ and SQLModel.
Requires Python: >=3.10

# Pipeteer

> Simple, explicit durable execution framework.

> [**Read the docs**](https://marciclabas.github.io/pipeteer/)

# Welcome to Pipeteer

Pipeteer **simplifies the complexity of durable execution** whilst *not hiding the underlying persistence*.

## Why Pipeteer?

Use `pipeteer` if you need...

- **Persistance**: your app can stop or crash and resume at any time without losing progress
- **Observability**: you can see the state of your app at any time, and *modify it* programmatically at runtime
- **Exactly-once semantics**: your app can be stopped and resumed without dropping or duplicating work
- **Fault tolerance**: if a task fails, it'll keep working on other tasks and retry it later
- **Explicitness**: `pipeteer`'s high level API is a very thin abstraction over SQLModel (for persistance) and ZeroMQ (for inter-process communication)

## Proof of Concept

**Definition.** You can define a durable workflow this easy:

```python
from pipeteer import activity, workflow, WorkflowContext

@activity()
async def double(x: int) -> int:
  return 2*x

@workflow()
async def quad(x: int, ctx: WorkflowContext) -> int:
  x2 = await ctx.call(double, x)
  x4 = await ctx.call(double, x2)
  return x4
```

**Worker.** And here's how to run it:

```python
import asyncio
from pipeteer import DB, Context

db = DB.at('pipeline.db')
ctx = Context.of(db)

async def main():
  await asyncio.gather(
    double.run(ctx),
    quad.run(ctx),
    ctx.zmq.proxy(),
  )
```

**Input**. How to give it tasks?
  
```python
from pipeteer import DB, Context

db = DB.at('pipeline.db')
ctx = Context.of(db)

Input = quad.input(ctx)
with db.session as s:
  s.add(Input(key='task', value=1, output='my-output'))
  s.commit()

await quad.notify(ctx)
```

**Output**. How to get the results?

```python
from sqlmodel import select
from pipeteer import DB, Context

db = DB.at('pipeline.db')
ctx = Context.of(db)

Output = quad.output(ctx, 'my-output')
while True:
  with db.session as s:
    for entry in s.exec(select(Output)):
      print(f'Output: {entry.key} -> {entry.value}')
      s.delete(entry)
    s.commit()
  await ctx.wait('my-output')
```
propertiesLiBr 0.1.0
A package for aqueous CaCl properties calculations
Requires Python: >=3.6

# Package Description

This file contains property data for aqueous sodium hydroxide solutions.

### Installation and Unsage

```
pip install propertiesNaOH
```

```python
# Import
import propertiesNaOH as NaOH

# Example Usage
p = 100000 # [Pa]
x = 0.4    # [%]  = [kgNaOH / kgSolution]
t_sat = NaOH.saturation_temperature(p, x)
print(t_sat)
```

### Available Property-Functions

| Function                        | Parameter 1           | Parameter 2           | Parameter 3    | Return Unit   |
|----------------------------------|-----------------------|-----------------------|----------------|---------------|
| saturation_temperature(P, x1)    | P (Pa)                | x (kgNaOH/kgSolution) | -              | °C            |
| enthalpy(x, T)                   | x (kgNaOH/kgSolution) | T (°C)                | -              | kJ/kg         |
| saturation_pressure(x, T)        | x (kgNaOH/kgSolution) | T (°C)                | -              | Pa            |
| dhdx(x, T)                       | x (kgNaOH/kgSolution) | T (°C)                | -              | kJ/kg         |
| dhdT(x, T)                       | x (kgNaOH/kgSolution) | T (°C)                | -              | kJ/kg·K       |
| specific_heat_capacity(x, T)     | x (kgNaOH/kgSolution) | T (°C)                | -              | kJ/kg·K       |
| density(x, T)                    | x (kgNaOH/kgSolution) | T (°C)                | -              | kg/m³         |
| dynamic_viscosity(x, T)          | x (kgNaOH/kgSolution) | T (°C)                | -              | Pa·s          |
| thermal_conductivity(x, T, p)    | x (kgNaOH/kgSolution) | T (°C)                | p (Pa)         | W/m·K         |


### Available Utilities


| Function                 | Description                  | Boolean Options + Defaults                              |
|--------------------------|------------------------------|---------------------------------------------------------|
| pTDiagram()              | shows pT-Diagram             | log=True, invT=True                                     |
|                          |                              | editablePlot=False, show_percentages=True               |
| crystallization_curve()  | shows crystallization curve  | return_data=False (if True, only data returned, no plot)|
exceptional-auth 0.6.1
Exception-based authentication helpers for django
Requires Python: >=3.7

# exceptional_auth

The purpose of this package is to provide a more flexible/powerful replacement for Django's `login_required` and `permission_required` decorators (and provide some entirely new related functionality).

The idea is to create a standard set of exceptions which any code can raise (even reusable apps distributed on pypi), and leave the handling of these exceptions up to the site developer (via custom middleware). This makes the many per-view decisions easy (ie. just raise PermissionDenied), while letting you centralize/delay the decision of what to do in those situations. Since you have access to the request object in the middleware methods, you can easily tailor the handling of these exceptions base on section of site, request type, etc.

We provide `exceptional_auth.BaseMiddleware`, a Middleware base class which makes it easier to handle our exceptions. Site developers should write a custom middleware extending this class, and add to `MIDDLEWARE` setting. You can also use `exceptional_auth.BaseMiddleware` to start with, and then extend it later.
django-view-models 0.1.0
Django models backed by database views
Requires Python: >=3.7

# django_view_models

Designed for Postgres. May or may not work with other databases.

## Installation/Usage
- `pip install django_view_models`
- add `django_view_models` to `INSTALLED_APPS`
- define view models (see below)
- `python manage.py sync_view_models` (run after every view definition change)

## Defining View Models

You must define the fields on your model, and either define `VIEW_DEFINITION` or `view_query` on your model. 

Note that just like regular models, django will add an integer primary key called `id`, unless you set `primary_key=True` on one of your fields.

```python
from django.db import models
from django_view_models.models import ViewModel, MaterializedViewModel

class Book(models.Model):
    title = models.TextField()
    is_good = models.BooleanField()

# create a ViewModel with a manual query
class GoodBook(ViewModel):
    title = models.TextField()

    VIEW_DEFINITION = '''
        SELECT id, title
        FROM my_app.book
        WHERE is_good = true
    '''

# create a ViewModel, and use Django's ORM to create the query
class BadBook(ViewModel):
    title = models.TextField()

    def view_query():
        return Book.objects.filter(is_good=False).values('id', 'title')
```
django-page-visibility 0.3.0
Implements a function to test whether a given url is currently visible to a given user.
Requires Python: >=3.7

DEPRECATED. This approach causes more headaches than it's worth.

# django_page_visibility

This package implements a standard protocol allowing developers to ask "can user X currently access page Y?". 

Rather than duplicating the permission checks performed in that view, you ask the view itself whether or not the user can access it.

## Conforming Views

Conforming views must implement a `.test_page_visibilty(request, *args, **kwargs)` method. This will be called with the same `args` and `kwargs` that the actual view would be called with. 

This method must return a truthy value if the user can access the page, and False otherwise. It may also raise an exception, to indicate that the user cannot access the page. See `PAGE_VISIBILITY_EXCEPTIONS` below.

## The Test Function

Developers can call `django_page_visibility.is_visible_to_user(path, user)` (see the code for details) to test visibility. Or, in a template, you can use our `is_permitted_to_see` filter or `permitted_link` tag.

## `PAGE_VISIBILITY_EXCEPTIONS` setting

By default, we return `False` if either `django.http.Http404` or `django.core.exceptions.PermissionDenied` are raised. You can override this by setting (in your django settings) `PAGE_VISIBILITY_EXCEPTIONS` to a list of exception classes. 

We expect most users to override this setting. For example, if you are using `exceptional_auth` and `django_early_return`, then you'll want to set:
```python
PAGE_VISIBILITY_EXCEPTIONS = [
    'django.core.exceptions.PermissionDenied',
    'django.http.Http404',
    'django_early_return.EarlyReturn',
    'exceptional_auth.AuthException',
]
```