semvec/pypi-packages huggingface dataset:
laserforce.py 2.0.0
Python package for laserforce.

# laserforce.py
[![Documentation Status](https://readthedocs.org/projects/laserforcepy/badge/?version=latest)](https://laserforcepy.readthedocs.io/en/latest/?badge=latest)
[![MIT](https://img.shields.io/pypi/l/gd.py.svg)](https://opensource.org/licenses/MIT)

A python package for Laserforce!
friendlyetl 1.0.4
A simple and lightweight ETL package for data pipelines using Python, Pandas, PySpark, and Hadoop
Requires Python: >=3.6

# FriendlyETL

A beginner-friendly and customizable Python ETL (Extract, Transform, Load) package designed for fast and efficient data workflows. Built using Pandas and compatible with files and databases, this package helps you automate your ETL pipelines with just a few lines of code.
url= https://github.com/divithraju
linkedin= https://www.linkedin.com/in/divithraju/
## 🔧 Features

- ✅ Extract data from CSV, Excel, JSON, or databases (MySQL)  
- ✅ Clean and transform datasets using common operations  
- ✅ Load data to CSV or back into MySQL databases  
- ✅ Modular and easy to extend for your own workflows  
- ✅ Designed for beginners, students, and professionals alike  

## 🗂 Project Structure

friendlyetl/
├── friendlyetl/
│ ├── init.py
│ ├── extract.py
│ ├── transform.py
│ ├── load.py
├── setup.py
├── README.md
└── dist/


## 🚀 Installation

Install the package from your local build:

```bash
pip install dist/friendlyetl-0.0.1-py3-none-any.whl

import friendlyetl as fetl

# Extract data from CSV
df = fetl.extract_data('input/sales.csv')

# Transform data
clean_df = fetl.clean_data(df)

# Load to MySQL
fetl.load_to_mysql(clean_df, db_name="sales_db", table_name="clean_sales")

 ## Dependencies
Python 3.6+

pandas

sqlalchemy

mysql-connector-python (if using MySQL)

Install all dependencies:

pip install -r requirements.txt
👤 Author
Divith Raju
Built with ❤️ to simplify ETL pipelines.
🔗 GitHub

📜 License
This project is licensed under the MIT License. See LICENSE file for more information.
Dingent 0.1.0
AI agent framework
Requires Python: <3.14,>=3.12

# Dingent

> **An Agent Framework for Simplified Data Retrieval Applications**

-----

## ⚠️ Disclaimer: Project Under Active Development

**Please Note:** Dingent is currently in its early development stages and has not yet been officially released. We are actively working on the core functionalities and documentation and will announce the first stable version soon.

The current `main` branch contains the latest experimental code and is subject to breaking changes at any time. We strongly advise against using it in a production environment.

Thank you for your understanding and patience\!

## ✨ Introduction

Dingent is a lightweight and user-friendly agent framework focused on simplifying the creation of data retrieval applications powered by Large Language Models (LLMs). Our goal is to provide a clean and powerful toolkit that enables you to quickly connect data sources (such as APIs, databases, or documents) to an LLM, building intelligent agents capable of question answering, data extraction, and analysis.

## 🚀 Core Features (Planned)

  * **Seamless LLM Integration**: Easily connect with major LLM providers like OpenAI, Anthropic, Google Gemini, and more.
  * **Declarative Data Sources**: Define your data interfaces with simple configurations, eliminating the need for extensive boilerplate code.
  * **Flexible Agent Construction**: Build upon an extensible Agent class, allowing you to freely compose tools and define custom agent behaviors.
  * **Out-of-the-Box Retrieval Strategies**: Get started quickly with built-in strategies for Retrieval-Augmented Generation (RAG) to optimize your data retrieval results.

## 💿 Installation (Coming Soon)

Detailed installation instructions will be available with the first official release. You will be able to install the package via pip:

```bash
# Coming soon!
pip install dingent
```

## 📖 Usage Example (Coming Soon)

We are working hard to provide clear documentation and rich code examples to help you get started.

## 🤝 Contributing

We welcome and appreciate community contributions\! However, until our first official release, we will not be accepting pull requests for new features.

If you have suggestions, bug reports, or ideas you'd like to discuss, please feel free to open an issue on the [GitHub Issues](https://github.com/saya-ashen/Dingent/issues) page.
tasker-tasks-cli 0.0.6
tasker: cli based task manager.

# TASKER: cli based task manager #

### Installation

```sh
pipx install tasker-tasks-cli
pipx ensurepath
```

### Description

*tasker* is a cli-based task manager.

Tasker tasks and config file will be saved to $HOME/tasker/

Consider converting $HOME/tasker into a repository post install.

### Usage

Type ```tasker``` to launch.

### Tips

 - Running ```tasker``` for the first time will create all necessary files in ```~/tasker/```, otherwise tasker will use existing files from any previous installs.

 - Config file location is set to ```~/tasker/conf/tasker.conf```

 - When executing ```tasker```, it has its own menu system. However you can incorporate tasker into your own scripts using command line options if you wish. EG: ```tasker -n get milk personal 2```

### Dependencies

Dependencies will be installed as part of pipx installation above.

 - configparser
 - iterfzf
 - python-dateutil
test-evaluator 0.1.2.dev2
Evaluate test cases using input/output dictionaries
Requires Python: >=3.6

# test_evaluator

**test_evaluator** is a lightweight and flexible Python library designed to evaluate your functions against test cases defined as input-output pairs using dictionaries. It's ideal for validating your solutions in competitive programming, development, or educational contexts.

![PyPI - Version](https://img.shields.io/pypi/v/test-evaluator?label=version)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/test-evaluator)
![License](https://img.shields.io/github/license/yourusername/test_evaluator)

---

## ✨ Features

- ✅ Evaluate multiple test cases at once  
- 🔁 Supports positional and keyword arguments  
- ❌ Easy identification of failed test cases  
- ⚡ Minimal setup, fast results  

---

## 📦 Installation

```bash
pip install test-evaluator
ormlet 0.1.0
Ormlet is a lightweight, minimal ORM designed to give you just enough structure and flexibility to build SQL queries.
Requires Python: >=3.13

<p align="center">
  <a href="https://pypi.org/project/ormlet/"><img src="./docs/ormlet.jpg" alt="Ormlet"></a>

</p>
<p align="center">
    <em>Ormlet is a lightweight, minimal ORM designed to give you just enough structure and flexibility to build SQL queries.</em>
</p>

---

The key features are:

- Declarative column definitions (IntegerField, TextField, etc.)
- Auto SQL generation for SELECT, INSERT, UPDATE, DELETE
- Fluent and chainable QueryBuilder
- Logical operators: AND, OR, multiple WHERE support

## Installation

Create and activate a virtual environment and then install **Ormlet**:

<div class="termy">

```console
$ pip install ormlet
---> 100%
Successfully installed ormlet
```

</div>

## Example

### Models

```Python hl_lines="3  6  11  20"
from ormlet import Model, column


class User(Model):
    __table__ = "users"

    id = column.IntegerField(primary_key=True, autoincrement=True)
    name = column.VarCharField(max_length=50)
    age = column.IntegerField()
```

### Database Manager

```Python hl_lines="3  6  11  20"
from ormlet import DatabaseManager

db = DatabaseManager("test.db")
db.register_tables([User])
```

### Queries

```Python hl_lines="3  6  11  20"
from ormlet import insert, select, update, delete

insert(User).values(id=1, name="Alice", age=30).execute(connection)
select(User).where(User.name == "Bob").execute(connection)
update(User).set(age=41).where(User.name == "Charlie").execute(connection)
delete(User).where(User.name == "Dan").execute(connection)
```

### Quick Example

```Python hl_lines="3  6  11  20"
from ormlet import DatabaseManager, Model, column

class User(Model):
    __table__ = "users"

    id = column.IntegerField(primary_key=True)
    name = column.VarCharField(max_length=50)
    age = column.IntegerField()

db = DatabaseManager("test.db")
db.register_tables([User])

with db.connect() as conn:
    insert(User).values(id=1, name="Alice", age=30).execute(conn)
    select(User).where(User.name == "Alice").execute(conn)
    update(User).set(age=41).where(User.name == "Alice").execute(conn)
    delete(User).where(User.id== 1).execute(conn)
```

## Dependencies

**Ormlet** uses no external dependencies it works with just standard Python.

## License

This project is licensed under the terms of the MIT license.

## Contributing

Feel free to open issues, suggest features, or submit PRs.
pythonic-fp-singletons 1.0.0
Singletons.
Requires Python: >=3.12
Keywords: singleton, sentinel

Pythonic FP - Singletons
========================

PyPI project
`pythonic-fp.fptools <https://pypi.org/project/pythonic-fp.singletons>`_.

Singleton classes representing

  - missing values (actually missing, not potentially missing)
  - sentinel values
  - failed calculations
  - subclassable Boolean datatype

This PyPI project is part of of the grscheller
`pythonic-fp namespace projects <https://github.com/grscheller/pythonic-fp/blob/main/README.md>`_

Documentation
-------------

Documentation for this project is hosted on
`GitHub Pages
<https://grscheller.github.io/pythonic-fp/singletons/development/build/html>`_.

Copyright and License
---------------------

Copyright (c) 2023-2025 Geoffrey R. Scheller. Licensed under the Apache
License, Version 2.0. See the LICENSE file for details.
django-markdown-database 0.1.2
Mount a directory of markdown files as a sqlite virtual table in Django
Requires Python: >=3.12

# Markdown files as a SQLite virtual table

This library provides a sqlite virtual table implementation that allows mounting
a directory of markdown files as a sqlite table.
This allows a user to take their markdown files from their favorite static site blog
or note taking system, and access them from Django as a sqlite table.

This initial release only supports read-only operations (SELECT) though a future
version will also support write operations (INSERT, UPDATE, DELETE)

Currently only supports sdist via PyPI, though a future version will attempt to
support a few platforms/versions as wheels.

# Usage

Add database connection to your settings.py

```python
DATABASES = {
    "default": {
        # Configure our database engine to this library
        "ENGINE": "markdowndb",
        # This is still a real sqlite database so your other models
        # can live here as usual
        "NAME": BASE_DIR / "db.sqlite3",
        # Optionally override the sqlite binary for `django-admin dbshell`
        # since the builtin MacOX sqlite does not allow loading modules
        "CLIENT": "/usr/local/opt/sqlite/bin/sqlite3",
        # Root path to our markdown files. Our models will ultimately be
        # built as ROOT / <model_label>
        "ROOT": BASE_DIR / "content"
    }
}
```

When creating models, add `required_db_vendor = "markdowndb"` and `managed = False` to your `Meta` class

```python
from markdowndb.mixins import FrontmatterModel

class MyNotes(FrontmatterModel)
    ...

    class Meta:
        required_db_vendor = "markdowndb"
        managed = False
```

The `FrontmatterModel` mixin provides access to many underlying fields by default.
See the comments on the model for specific fields.

## Custom lookups

Our `FrontmatterModel` provides a `metadata` JSONField that we can use to get the entire frontmatter, but we can also configure a custom lookup.

Assuming frontmatter like the following

```markdown
---
title: Some title
date: 2025-01-01 01:02:03
tags:
  - one
  - two
---

An excerpt for here.

<!--more-->

The longer blog post here.
```

We can define a custom model

```python
from markdowndb.mixins import FrontmatterModel

class MyNotes(FrontmatterModel)
    title = models.CharField()
    date = models.DatetimeField()

    class Meta:
        required_db_vendor = "markdowndb"
        managed = False
```

We have various ways of accessing our model

```python
# Lets get our first note as a quick test
note = MyNotes.objects.first()
# By default, our primary key will match the file inode since that should be
# a constant indicator
note.pk == note.inode
# Calling the attribute directly returns 'Some title'
note.title
# As does getting the attribute from the metadata
note.metadata['title']
# Getting our post date lets Django process as a datetime value
note.date
# Though we can also pull the original string directly without conversion
note.metadata['date']
```