semvec/pypi-packages huggingface dataset:
trainy-mlop-nightly 0.0.2.dev20260112105316
Trainy MLOp
Requires Python: <4.0,>=3.10

[![pypi](https://img.shields.io/pypi/v/mlop)](https://pypi.org/project/trainy-mlop-nightly/)

## THIS README/REPO IS CURRENTLY UNDER CONSTRUCTION WHILE WE UPDATE THE REFERENCES IN OUR FORK

**mlop** is a Machine Learning Operations (MLOps) framework. It provides [self-hostable superior experimental tracking capabilities and lifecycle management for training ML models](https://github.com/mlop-ai/server). To get started, [try out our introductory notebook](https://colab.research.google.com/github/mlop-ai/mlop/blob/main/examples/intro.ipynb) or [get an account with us today](https://trakkur.trainy.ai/auth/sign-up)!

## 🎥 Demo

**mlop** adopts a KISS philosophy that allows it to outperform all other tools in this category. Supporting high and stable data throughput should be *THE* top priority for efficient MLOps.
<video loop src='https://github.com/user-attachments/assets/efd9720e-6128-4278-85ec-ee6139a851af' alt="demo" width="1200" style="display: block; margin: auto;"></video>

<p align="center">
<strong>mlop</strong> logger (bottom left) v. a conventional logger (bottom right)
</p>

## 🚀 Getting Started

- Try **mlop** on our platform in [a notebook](https://colab.research.google.com/github/mlop-ai/mlop/blob/main/examples/intro.ipynb) & start integrating in just 5 lines of Python code:

```python
%pip install -Uq "mlop[full]"
import mlop

mlop.init(project="hello-world")
mlop.log({"e": 2.718})
mlop.finish()
```

- Self-host your very own **mlop** instance & get started in just 3 commands with **docker-compose**

```bash
git clone --recurse-submodules https://github.com/mlop-ai/server.git; cd server
cp .env.example .env
sudo docker-compose --env-file .env up --build
```

You may also learn more about **mlop** by checking out our [documentation](https://docs.mlop.ai/).

You can try everything out in our [introductory tutorial](https://colab.research.google.com/github/mlop-ai/mlop/blob/main/examples/intro.ipynb) and [torch tutorial](https://colab.research.google.com/github/mlop-ai/mlop/blob/main/examples/torch.ipynb).  

## 🛠️ Development Setup

Want to contribute? Here's the quickest way to get the local toolchain (including the linters used in CI) running:

```bash
git clone https://github.com/mlop-ai/mlop.git
cd mlop
python -m venv .venv && source .venv/bin/activate   # or use your preferred environment manager
python -m pip install --upgrade pip
pip install -e ".[full]"
```

Linting commands (mirrors `.github/workflows/lint.yml`):

```bash
bash format.sh
```

Run these locally before sending a PR to match the automation that checks on every push and pull request.

## 🫡 Vision

**mlop** is a platform built for and by ML engineers, supported by [our community](https://discord.com/invite/HQUBJSVgAP)! We were tired of the current state of the art in ML observability tools, and this tool was born to help mitigate the inefficiencies - specifically, we hope to better inform you about your model performance and training runs; and actually **save you**, instead of charging you, for your precious compute time! 

🌟 Be sure to star our repos if they help you ~
ft_package-nettalha 0.1.0
A simple Python package with function to count occurrences of a word in a list.
Requires Python: >=3.9

# ft_package-nettalha

A simple Python function to count occurrences of a word in a list.

## Installation

You can install this package using pip:

```bash
pip install ft_package-nettalha
```

## Usage

Import the function and use it as follows:
```python
from ft_package-nettalha import count_in_list

words = ['apple', 'banana', 'apple', 'orange', 'apple']
search_word = 'apple'
result = count_in_list(words, search_word)
print(result)  # Output: 3
```

## Author

Noureddine Ett

## License

This project is licensed under the terms of the MIT license.
django-prod 0.1.3
Quickly deploy over SSH your newly generated django project.
Requires Python: >=3.13

# django-prod

Quickly deploy over SSH your newly generated django project.

---

This package provides two management commands:

- `django_prod_init` — generates all production files you need.
- `django_prod_deploy` — deploys your project to a remote SERVER over SSH.

---

## 📦 Installation

Install the package:

```bash
pip install django-prod
```

---

## 🛠 Example

Create a new django project:

```bash
django-admin startproject webapp .
```

Add django-prod to installed apps:
```bash
# settings.py
INSTALLED_APPS = [
    ...
    "django_prod",
]
```

Initialize production files:
```bash
python manage.py django_prod_init
```

Deploy to your server:
```bash
python manage.py django_prod_deploy
```
You will be prompted for:

- Server IP address
- SSH username
- Path to your SSH private key

![Prompted With](doc_images/prompted.png)

Then the script will:

- Upload your project to the server
- Ensure Docker is installed
- Run your production stack with Docker Compose

---

This project is **opinionated** and uses the simplest technologies possible to move from development to production quickly.
It relies on **SQLite** as the production database, and for those who still consider SQLite a “toy database,” I strongly encourage you to look into its performance when properly configured. That’s why the project includes a dedicated configuration to get the most out of SQLite (see **settings_prod.py**).

It also uses **WhiteNoise** to handle static files. Performance is more than acceptable once assets are cached and served through a CDN (for example, a Cloudflare proxy).

The third technology used is **Docker** and **Docker Compose**. no need to explain why :)
akane 1.1.0
Simple, stronly typed library to create tests for anything

# akane

A very simple, strongly typed library to easily create test cases for anything.

> **Info**  
> This project is mostly purpose built to create e2e integration tests for my CLI apps
> (like [goup](https://github.com/zekroTJA/goup), for example). I wanted something lean
> which takes almost no effort to write tests with. Feel free to use it for your own 
> projects, but don't expect a great developer experience.  
>
> If you are looking for proper testing libraries, feel free to take a look into the
> following resources.  
> - [unittest](https://docs.python.org/3/library/unittest.html)
> - [Robot Framework](https://robotframework.org/)
> - [pytest](https://github.com/pytest-dev/pytest)

## Installation

```
pip install akane
```

or

```
pip install git+https://github.com/zekrotja/akane.git
```

## Example

> This example is also availble in the [examples](examples/simple/main.py) directory.
```py
import os
import akane
from akane.assertions import assert_eq
from akane.procedures import setup, test, teardown


@setup()
def init_env_vars():
    os.environ["FOO"] = "bar"


@test(name="environment variables")
def test_env():
    assert_eq("bar", os.environ["FOO"])


@test(name="environment in shell")
def test_cmd():
    res = akane.exec(("sh", "-c", "echo $FOO"))
    assert_eq("bar\n", res)


@test(name="failing test")
def fails():
    return (False, "whoops")


@teardown(name="environment variables")
def delete_env_vars():
    del os.environ["FOO"]


def main() -> int:
    return akane.run_all()


if __name__ == "__main__":
    exit(main())
```
ucp-sdk 0.1.1
UCP Python SDK
Requires Python: >=3.10

<!--
   Copyright 2026 UCP Authors

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-->

<p align="center">
  <h1 align="center">UCP Python SDK</h1>
</p>

<p align="center">
  <b>Official Python library for the Universal Commerce Protocol (UCP).</b>
</p>

## Overview

This repository contains the Python SDK for the
[Universal Commerce Protocol (UCP)](https://ucp.dev). It provides Pydantic
models for UCP schemas, making it easy to build UCP-compliant applications
in Python.

## Installation

For now, you can install the SDK using the following commands:

```bash
# Create a directory for the SDK
mkdir sdk

# Clone the repository
git clone https://github.com/Universal-Commerce-Protocol/python-sdk.git sdk/python

# Navigate to the directory
cd sdk/python

# Install dependencies
uv sync
```

## Development

### Prerequisites

This project uses `uv` for dependency management.

### Generating Pydantic Models

The models are automatically generated from the JSON schemas in the UCP
Specification.

To regenerate the models:

```bash
uv sync
./generate_models.sh
```

The generated code is automatically formatted using `ruff`.

## Contributing

We welcome community contributions. See our [Contribution Guide](https://github.com/Universal-Commerce-Protocol/ucp/blob/main/CONTRIBUTING.md) for details.

## License

UCP is an open-source project under the [Apache License 2.0](LICENSE).