semvec/pypi-packages huggingface dataset:
singleapi-client 0.1.0
Official Python SDK for SingleAPI
Requires Python: >=3.7

# SingleAPI Python SDK

The official Python SDK for SingleAPI, providing easy access to the SingleAPI platform for vector database management, embeddings, and context management with ECP (Ephemeral Context Protocol).

## Installation

```bash
pip install singleapi-client
```

## Quick Start

```python
from singleapi import SingleAPI

# Initialize the client with your API key
client = SingleAPI(api_key="your_api_key")

# Create a context
context = client.create_context(
    metadata={"user_id": "user123", "session_id": "session456"}
)

# Store vectors with context
vectors = [
    [0.1, 0.2, 0.3],
    [0.4, 0.5, 0.6],
]
metadata = [
    {"text": "Document 1", "source": "source1"},
    {"text": "Document 2", "source": "source2"},
]
client.store_vectors(vectors=vectors, metadata=metadata, context_id=context.id)

# Query vectors
results = client.query_vectors(
    query_vector=[0.2, 0.3, 0.4],
    context_id=context.id,
    top_k=5
)

# Print results
for result in results:
    print(f"Score: {result.score}, Metadata: {result.metadata}")

# Use ECP for context management
with client.context(metadata={"task": "recommendation"}) as ctx:
    # All operations within this block will use this context
    client.store_vectors(vectors=vectors, metadata=metadata)
    results = client.query_vectors(query_vector=[0.2, 0.3, 0.4], top_k=5)
```

## Features

- Simple, intuitive API for vector database operations
- Built-in support for ECP (Ephemeral Context Protocol)
- Automatic handling of authentication and API key management
- Comprehensive error handling and retries
- Support for all SingleAPI features:
  - Vector storage and retrieval
  - Context management
  - Subscription and plan management
  - Cloud deployment

## Documentation

For complete documentation, visit [https://docs.singleapi.com/python-sdk](https://docs.singleapi.com/python-sdk).

## Examples

### Managing Subscriptions

```python
# Get current subscription
subscription = client.get_subscription()
print(f"Current plan: {subscription.plan_id}")
print(f"Status: {subscription.status}")

# Check usage limits
limits = client.check_limits()
if limits.approaching_limit:
    print(f"Warning: Approaching limit for {limits.approaching_limit_type}")
```

### Cloud Deployment

```python
# Deploy to AWS
result = client.deploy_to_aws(
    account_id="123456789012",
    region="us-east-1",
    resources=[
        {
            "type": "s3_bucket",
            "name": "my-vector-storage"
        },
        {
            "type": "dynamodb_table",
            "name": "my-metadata-table"
        }
    ]
)
print(f"Deployment ID: {result.deployment_id}")
```

## License

This SDK is distributed under the MIT license. See the LICENSE file for more information.
pyskindose 25.1.1
Tools and script for calculating peak skin dose and create dose maps for fluoroscopic exams from RDSR data
Requires Python: >=3.10

[![ci](https://github.com/rvbCMTS/PySkinDose/actions/workflows/ci.yml/badge.svg)](https://github.com/rvbCMTS/PySkinDose/actions/workflows/ci.yml) [![codecov](https://codecov.io/gh/rvbCMTS/PySkinDose/branch/master/graph/badge.svg?token=2O32UO12V6)](https://codecov.io/gh/rvbCMTS/PySkinDose) [![Documentation Status](https://readthedocs.org/projects/pyskindose/badge/?version=latest)](http://pyskindose.readthedocs.io/en/latest/?badge=latest)

# pyskindose

author: Max Hellström

A python program for calculating 3D skin dose maps based on DICOM X-ray Radiation Dose Structured Reports.

Requires Python 3.8 or above. NB! Will soon be upgraded to require Python 3.10 or above.

The documentation is under construction and can be found at [https://pyskindose/readthedocs.io](https://pyskindose.readthedocs.io)

Stay tuned!
apigene-mcp 0.1.0
Apigene MCP Server
Requires Python: >=3.11

# Apigene MCP Server

A lightweight Model Context Protocol (MCP) server integration for Apigene’s API, built on FastMCP. Enables MCP‑compatible clients (e.g., Claude Desktop) to invoke Apigene endpoints via a standardized tool.

---

## 🚀 Features

- MCP server powered by `mcp.server.fastmcp.FastMCP`
- Single tool: `execute_action` — forwards intent to Apigene’s `/api/interaction/create` endpoint
- Async HTTP requests via `httpx`
- Configurable via environment variables

---

## 📋 Requirements

- Python 3.10+
- Conda or virtualenv

---

---

## Docker build command

1. docker login -u yanivapigene
2. docker build -t apigene-mcp .
3. docker tag apigene-mcp:latest apigene/apigene-mcp:latest
4. docker push apigene/apigene-mcp:latest

---

## ⚙️ Installation

```bash
git clone https://github.com/apigene/apigene-mcp.git
cd apigene-mcp
pip install -r requirements.txt
```

## Claude Desktop Config

### Local developement

```json
{
  "mcpServers": {
    "apigene": {
      "command": "/opt/miniconda3/bin/uv",
      "args": [
        "--directory",
        "/Users/yaniv/apigene//apigene-mcp",
        "run",
        "apigene.py"
      ],
      "env": {
        "APIGENE_SERVER_URL": "https://dev.apigene.ai",
        "APIGENE_API_KEY": "<YOUR_API_KEY>"
      }
    }
  }
}
```

### Docker

```json
{
  "mcpServers": {
    "apigene": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "APIGENE_SERVER_URL",
        "APIGENE_API_KEY",
        "apigene-mcp"
      ],
      "env": {
        "APIGENE_SERVER_URL": "https://dev.apigene.ai",
        "APIGENE_API_KEY": "<YOUR_API_KEY>"
      }
    }
  }
}
```

## claude_desktop_config.json location on MAC

```bash
code ~/Library/Application\ Support/Claude/claude_desktop_config.json
```

## view apigene MCP server logs location on MAC

```bash
cd ~/Library/Logs/Claude/
cat mcp-server-apigene.log
cat mcp.log
```
pylibfdt 1.7.2.post1
Python binding for libfdt

This tree contains a copy of libfdt from the upstream dtc project for the
purposes of pypi.org packaging. Other than changes to the packaging files,
changes should be made upstream. The upstream sources are here:

git://git.kernel.org/pub/scm/utils/dtc/dtc.git


To install this you will need to install swig and Python development files.

On Debian distributions:

   sudo apt-get install swig python3-dev


The module can be installed with pip:

   pip install pylibfdt

or via setup.py:

   ./setup.py install [--user]
Thermalift 1.0
Calculator of the thermal lift effect in geothermal wells
Requires Python: >=3.11
Keywords: geothermal, reservoir engineering, well test

# Thermalift

**Calculator for eliminating the thermal lift effect from production data in geothermal wells.**

Thermalift was developed as part of the [GeoModel](https://geomodel.pl/en/) project.

The user's guide can be found in the docs directory or [here](https://github.com/maciejmiecznik/thermalift/blob/main/docs/Thermalift_1.0_user_guide.pdf)


The output from Thermalift calculator can be a figure similar to the below one, showing how thermal lift influences the observed water table level or water table drawdown.

![Thermalft output figure](https://github.com/maciejmiecznik/thermalift/blob/main/examples/Case%20ST/Test%20well%20raw%20and%20corrected%20pumping%20data_thermal_lift.png?raw=true)


Thermalift is a part of project "Optimal management of low-temperature geothermal reservoirs – Polish-Icelandic cooperation on reservoir modelling" (acronym GeoModel), financed under the Fund for Bilateral Relations through the [European Economic Area Financial Mechanism (EEA FM) and the Norwegian Financial Mechanism (NFM)](https://eeagrants.org/) 2014-2021 under the Environment, Energy and Climate Change Programme.
st-screenwidth-detector 0.1.4
Get current screen width when screen size changes
Requires Python: >=3.12

# Streamlit Screen Width Detector

> Get current screen width when screen size changes

## Usage

Installation:

```sh
uv add st-screenwidth-detector
```

Get current screen width dynamically(trigger app rerun) when screen size changes:

```python
from st_screenwidth_detector import screenwidth_detector

st.write("screen width:", screenwidth_detector())
```
eea.frame 0.5.8
Django integration middleware for EEA Zope websites

EEA Frame
=========

Django integration middleware for EEA Zope websites.


Template and request
--------------------

``pip install eea.frame``

In your project's ``settings.py`` add::

  INSTALLED_APPS = (
  ... # django apps
  'frame'
  ... # your project's apps
  )
 
  MIDDLEWARE_CLASSES = (
    'frame.middleware.RequestMiddleware',
    'frame.middleware.UserMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
  )
  
  TEMPLATE_LOADERS = (
    'frame.middleware.Loader',
    'django.template.loaders.filesystem.Loader',
    'django.template.loaders.app_directories.Loader',
  )
  
Also, usually in ``local_settings.py`` you need to define: ``FRAME_URL`` to an
url pointing to a Zope frame instance, and
``FRAME_COOKIES = ['__ac', '_ZopeId', '__ginger_snap']``.

You can skip https with ``FRAME_VERIFY_SSL = False``.

Your ``layout.html`` must extend ``"frame.html"`` in order to use the frame.

You can set ``FRAME_EXTRA_SUBSTITUTIONS`` to a list of pairs to be replaced
in the frame html.

Authentication Backend
----------------------
If you want to use the Django groups and permissions settings with users from
_eea.frame_, you need to set::

  MIDDLEWARE_CLASSES = (
    ...
    'django.contrib.auth.middleware.RemoteUserMiddleware',
    ...
  )

  AUTHENTICATION_BACKENDS = (
    'django.contrib.auth.backends.ModelBackend',
    'frame.backends.FrameUserBackend',
  )

For each user that is authenticated on *eea.frame*, a
``django.contrib.auth.models.User`` instance is created.

For each of the roles the user has in *eea.frame*, a
``django.contrib.auth.models.Group`` instance is created, and you can assign
permissions to that group.

Seen Middleware
---------------
Use the seen middleware to keep for each user the datetime of the last visit
to the application.

Set (at the end of the middleware classes setting)::

  MIDDLEWARE_CLASSES = (
    ...
    'frame.middleware.SeenMiddleware',
  )

If you want to use the default view, add
``frame.utils.get_objects_from_last_seen_count`` to your url patterns, in a
location such as ``^/_lastseen/$``, then set the ``FRAME_SEEN_MODELS`` to a
list of pairs (model, field) for the objects to be counted.

You should exclude this view using ``FRAME_SEEN_EXCLUDE`` config setting.
collagemaker-tspspi 0.0.1
A simple photo collage generator
Requires Python: >=3.6

# A simple collage generator

A very simple generator for image collages out of a set of images. Currently
all images are resized into a square format and then places on one or more lines,
partially overlapping and rotated in random orientations.

## Installation

```
pip install collagemaker-tspspi
```

## Usage

```
usage: collagemaker [-h] --output OUTPUT [--lines LINES] [--bgcolor BGCOLOR]
                    [--overlap OVERLAP] [--lineoverlap LINEOVERLAP]
                    images [images ...]

Create a flowing image collage with overlap and rotation.

positional arguments:
  images                Input image files

options:
  -h, --help            show this help message and exit
  --output OUTPUT       Output file
  --lines LINES         Number of lines (default: 2)
  --bgcolor BGCOLOR     Background color (CSS name or #RRGGBB[AA], default:
                        transparent)
  --overlap OVERLAP     Fractional horizontal overlap between images (default:
                        0.3)
  --lineoverlap LINEOVERLAP
                        Fractional vertical overlap between lines (default:
                        0.1)
```
heap-mapping 0.1.0
An implementation of a Min-Max Heap with a MutableMapping interface.
Requires Python: >=3.12

# heap-mapping

This is a library containing an implementation of the min-max heap data
structure, which allows for $O(log(n))$ retrieval or removal of both the
minimum and maximum elements of the heap, as well as insertion and keys and
changes to their priorities. Heap creation can be additionally performed in
$O(n)$ time.

The data structure can be accessed as `MutableMapping`; keys are the
"values" stored in the data structure, and values are their priorities.

## Getting started

You can construct a `MinMaxHeap` from a list of values.

```python
from heap_mapping import MinMaxHeap

heap = MinMaxHeap([5, 0, 4, 1, 2, 9, 8])
print(heap.min_value) # 0
print(heap.max_value) # 9
```

By default, priorities are the same as the values.

```python
print(heap[5]) # 5
```

You can specify a key function
in the constructor to get a priority from each element.

```python
heap2 = MinMaxHeap([5, 0, 4, 1, 2, 9, 8], key=lambda x: -x)
print(heap2.min_value) # 9
print(heap2.max_value) # 0
print(heap2[5]) # -5
```

You can add elements with the `add` method. By default, the key function
specified in the constructor is used to get the priority.

```python
heap2.add(7)
print(heap2[7]) # -7
```

Alternatively, you can manually specify a key.

```python
heap2.add(6, -3)
print(heap2[6]) # -3
```

You can change the priorities after they've been inserted.

```python
heap2[7] = 1
print(heap2.max_value) # 7
```

You can look up and delete arbitrary elements in $O(log(n))$ time.

```python
del heap2[6]
print(6 in heap2) # False
```

Iteration is performed out of order. Note that this order is also *not* the
order in which the elements are stored in the heap!

```python
print(list(heap2)) # [5, 0, 4, 1, 2, 9, 8, 7]
```
openapi-cli 0.2.1.14
Use OpenAPI schema to generate command line client
Requires Python: <4,>=3.11

# OpenAPI CLI

OpenAPI CLI is a command-line interface (CLI) tool designed to interact with APIs generated by `openapi-python-client`. This tool allows you to configure and use API clients with ease.

## Features

- Configure API client modules
- Validate client modules
- Generate API client instances

## Installation

To install OpenAPI CLI, use `poetry`:

```sh
poetry add openapi-cli[full]
```

To install the CLI globally, use `pip`:

```sh
pip install openapi-cli[full]
```

## Optional
If you want to just use separator for your operation ids use:

```bash
poetry add openapi-cli
```

This will not have a cli, but you can use the separator in your code.
If you want to still have ability to generate clients use the following:

```bash
poetry add openapi-cli[full] --group dev
```

This will keep your project build clean and will not install the cli in your production environment.

## Usage

To use OpenAPI CLI in your project add the following to your `pyproject.toml`:

```toml

    [tool.poetry.scripts]
    your-api-cli = "openapi_cli:cli"

```

Then, you can run the CLI using in venv activated shell:

```sh

    your-api-cli --help

```

### Configure the CLI

Before using the CLI, you need to configure it with your client module, base URL, and token.

Install the client module using downloaded module using `openapi-python-client`:
```sh
your-api-cli client install --module <name_of_your_module> 
```

Set the base URL and token for the client module:

```sh
openapi client api-config --base-url <url_of_your_api>
openapi client auth --token <your_token>
```

Patch the client to support nesting:

```sh
openapi client patch --separator <your_operation_id_separator>  # default is '_oaps_'
```

You can import separator to integrate it with your code:

```python
from openapi_cli.separator import CLI_SEPARATOR
```

### Requirements

- Python 3.12+
- Poetry

### Setup

1. Clone the repository.
2. Install dependencies using `poetry install`.

### Code Formatting

This project uses `black` and `isort` for code formatting. To format the code, run:

```sh
poetry run black .
poetry run isort .
```

## License

This project is licensed under the MIT License. See the `LICENSE` file for more details.
bigflow 1.11.3
BigQuery client wrapper with clean API

# BigFlow

## Documentation

1. [What is BigFlow?](#what-is-bigflow)
1. [Getting started](#getting-started)
1. [Installing Bigflow](#installing-bigflow)
1. [Help me](#help-me)
1. [BigFlow tutorial](docs/tutorial.md)
1. [CLI](docs/cli.md)
1. [Configuration](./docs/configuration.md)
1. [Project structure and build](./docs/project_structure_and_build.md)
1. [Deployment](docs/deployment.md)
1. [Workflow & Job](./docs/workflow-and-job.md)
1. [Starter](./docs/scaffold.md)
1. [Technologies](./docs/technologies.md)
1. [Development](./docs/development.md)

## Cookbook

* [Monitoring](./docs/monitoring.md)
* [Automated end-to-end testing](./docs/e2e_testing.md)
* [Dockerized, GPU based ML prediction process](./docs/ml-prediction.md)


## What is BigFlow?

BigFlow is a Python framework for data processing pipelines on [GCP](https://cloud.google.com/).

The main features are:

* [Dockerized deployment environment](./docs/project_structure_and_build.md#overview)
* [Powerful CLI](./docs/cli.md)
* [Automated build](./docs/project_structure_and_build.md#overview), [deployment](./docs/deployment.md),
[versioning](./docs/project_structure_and_build.md#project-versioning) and [configuration](./docs/configuration.md)
* [Unified project structure](./docs/project_structure_and_build.md#project-structure)
* [Support for GCP data processing technologies](./docs/technologies.md) — [Dataflow](https://beam.apache.org/) (Apache Beam) and [BigQuery](https://cloud.google.com/bigquery)
* [Project starter](./docs/scaffold.md)

## Getting started

Start from installing BigFlow on your local machine.
Next, go through the BigFlow [tutorial](./docs/tutorial.md).

## Installing BigFlow

**Prerequisites**. Before you start, make sure you have the following software installed:

1. [Python](https://www.python.org/downloads/) = 3.8
2. [Google Cloud SDK](https://cloud.google.com/sdk/docs/downloads-interactive)
3. [Docker Engine](https://docs.docker.com/engine/install/)

You can install the `bigflow` package globally, but we recommend
installing it locally with `venv`, in your project's folder:

```bash
python -m venv .bigflow_env
source .bigflow_env/bin/activate
```

Install the `bigflow` PIP package:

```bash
pip install bigflow[bigquery,dataflow]
```

Test it:

```shell
bigflow -h
```

Read more about [BigFlow CLI](docs/cli.md).

To interact with GCP you need to set a default project and log in:

```shell script
gcloud config set project <your-gcp-project-id>
gcloud auth application-default login
```

Finally, check if your Docker is running:

```shell script
docker info
```

## Help me

You can ask questions on our [gitter channel](https://gitter.im/allegro/bigflow) or [stackoverflow](https://stackoverflow.com/questions/tagged/bigflow).
lscl 0.5
Logstash configuration language handling
Requires Python: <4.0,>=3.11
Keywords: logstash, lscl

lscl -- Logstash configuration language handling
================================================

lscl is a Python module for parsing and rendering Logstash_ configurations
in its own language, named LSCL for "LogStash Configuration Language".

The project is present at the following locations:

* `Official website and documentation at
  lscl.touhey.pro <lscl website_>`_;
* `lscl repository on Gitlab <lscl on Gitlab_>`_;
* `lscl project on PyPI <lscl on PyPI_>`_.

As described in `Reading Logstash configurations`_ and `Rendering
Logstash configurations`_, you can use this module to create, parse, update
and render Logstash pipelines. Here is an example where lscl is used to add
an ``add_field`` operation on an existing pipeline:

.. code-block:: python

    from lscl.lang import LsclAttribute, LsclBlock
    from lscl.parser import parse_lscl
    from lscl.renderer import render_as_lscl


    SOURCE = """
    input {
        stdin { }
    }
    filter {
        dissect {
            mapping => {
                "message" => "[%{ts}] %{message}"
            }
        }
    }
    output {
        elasticsearch { codec => rubydebug }
    }
    """

    content = parse_lscl(SOURCE)

    # Find the 'filter' block at top level.
    # If the block is not found, create it.
    for el in content:
        if isinstance(el, LsclBlock) and el.name == "filter":
            break
    else:
        el = LsclBlock(name="filter")
        content.append(el)

    # Add the add_field filter.
    el.content.append(
        LsclBlock(
            name="mutate",
            content=[
                LsclAttribute(name="add_field", content={"mytag": "myvalue"}),
            ],
        )
    )

    print(render_as_lscl(content), end="")

The script will output the following:

.. code-block:: text

    input {
      stdin {}
    }
    filter {
      dissect {
        mapping => {
          message => "[%{ts}] %{message}"
        }
      }
      mutate {
        add_field => {
          mytag => myvalue
        }
      }
    }
    output {
      elasticsearch {
        codec => rubydebug
      }
    }

.. _Logstash: https://www.elastic.co/fr/logstash
.. _lscl website: https://lscl.touhey.pro/
.. _lscl on Gitlab: https://gitlab.com/kaquel/lscl
.. _lscl on PyPI: https://pypi.org/project/lscl
.. _Reading Logstash configurations:
    https://lscl.touhey.pro/developer-guides/read.html
.. _Rendering Logstash configurations:
    https://lscl.touhey.pro/developer-guides/render.html
SuperEasyPython 0.1.0
EasyPython
Requires Python: >=3.6

# Web
Web working with Fetch_url and scraple_links
Fetch_url it's get url
Scraple link it's parse url
# Data
Data is list with information
# Download
Download it's just  download
Download_file("Link")
# Gui
Gui working on PySide6
Gui it's just a PySide6
# Files
Files working on json with read_lines and write_json
# Telegram
Telegram working on Aiogram
And it's just aiogram 
# Examples
You can read code in folder examples