semvec/pypi-packages huggingface dataset:
codestory-cli 0.2.2
Every project should have a good story behind it. With a good story (git history), you can reason about changes in a way that would be impossible just looking at a codebase. But let us do the work in creating that story
Requires Python: >=3.11

# <img src="resources/icon.svg" width="32" height="32" align="center" /> Codestory CLI

![Tests](https://img.shields.io/github/actions/workflow/status/CodeStoryBuild/CodeStoryCli/pytest.yml?label=tests)
![Docs Deployment](https://img.shields.io/github/actions/workflow/status/CodeStoryBuild/CodeStoryCli/deploy-docs.yml?label=docs)
![GitHub Release](https://img.shields.io/github/v/release/CodeStoryBuild/CodeStoryCli?include_prereleases&label=release)
![PyPI Version](https://img.shields.io/pypi/v/codestory-cli?color=blue&label=pypi&cacheSeconds=86400)
![PyPI Downloads](https://img.shields.io/pypi/dm/codestory-cli?color=blue&label=downloads&cacheSeconds=86400)

The Codestory CLI is a high level interface over git. Why?
Git is a powerful tool. It is also an excellent tool for shooting yourself in the foot.

While Git provides the infrastructure for version control, you rarely need to be down in the pipes for daily work. Codestory lets you do 99% of regular tasks much more effectively. When you need Git, its always there for those more complex tasks. It does not replace Git; it allows you to use it effectively without the headache.

Codestory provides powerful commands to enhance your version control workflow: commit changes into small, logical commits with AI-generated messages; fix past commits by intelligently splitting them into more focused changes; clean entire repository histories to improve commit quality; and configure settings to tailor the tool to your needs.

Think of this as a natural transition to a higher-level version control, where you can worry less about housekeeping and focus on building.

## Getting Started

For detailed instructions on how to install and use the Codestory CLI, visit our **[getting started](https://cli.codestory.build/docs/getting-started/)** page.

## Documentation

For comprehensive guides, configuration priority, and supported languages, visit our **[docs](https://cli.codestory.build/docs)** page.

The documentation site provides detailed information on:

- [Usage Guides](https://cli.codestory.build/docs/usage/)
- [Configuration Scopes (Global vs. Local vs. Env)](https://cli.codestory.build/docs/configuration/)
- [Supported Model Providers and Languages](https://cli.codestory.build/docs/reference/supported/)
- [Core Design and Architecture](https://cli.codestory.build/docs/design/)

## Main-Cleaned

For a real example of what codestory can do, checkout the `main-cleaned` branch of this repository. It is a cleaned up version of the main branch of this repository, created using the `cst clean` command.

## Contributing

If you find a bug, feel free to create a pull request.

## License

The code is licensed under GPLv2, just like Git.
ellipsis 3.3.6
Package to interact with the Ellipsis API
Requires Python: >=3.6

# Ellipsis Drive Python Package

This package is meant to help you interact with the Ellipsis API.

You can install this package using

`pip install ellipsis`

For documentation see https://ellipsis-package.readthedocs.io

This package is meant to ease the use of the Ellipsis Drive API in your Python projects.

# Examples

Below are some code examples.

    import ellipsis as el

    # log in
    token = el.account.logIn("username", "password")

    # retrieve all maps in "My Drive"
    maps = el.account.listRoot("myDrive", pathType='layer',
    token=token)

Another example

    import ellipsis as el

    folderId = '46e1e919-8b73-42a3-a575-25c6d45fd93b'

    token = el.account.logIn("username", "password")

    info = el.path.get(folderId, token)
    layers = el.path.listPath(folderId, pathType='layer', token = token, listAll = True)
    folders = el.path.listPath(folderId, pathType='folder', token = token, listAll = True)
azure-kusto-ingest 6.0.2
Kusto Ingest Client
Requires Python: >=3.9
Keywords: azure, kusto, ingest, data, analytics

Microsoft Azure Kusto Ingest Library for Python
===============================================

.. code-block:: python

    from azure.kusto.data import KustoConnectionStringBuilder, DataFormat
    from azure.kusto.ingest import QueuedIngestClient, IngestionProperties, FileDescriptor, BlobDescriptor

    ingestion_props = IngestionProperties(database="{database_name}", table="{table_name}", data_format=DataFormat.CSV)
    client = QueuedIngestClient(KustoConnectionStringBuilder.with_interactive_login("https://ingest-{cluster_name}.kusto.windows.net"))

    file_descriptor = FileDescriptor("{filename}.csv", 15360)  # in this example, the raw (uncompressed) size of the data is 15KB (15360 bytes)
    client.ingest_from_file(file_descriptor, ingestion_properties=ingestion_props)
    client.ingest_from_file("{filename}.csv", ingestion_properties=ingestion_props)

    blob_descriptor = BlobDescriptor("https://{path_to_blob}.csv.gz?sas", 51200)  # in this example, the raw (uncompressed) size of the data is 50KB (52100 bytes)
    client.ingest_from_blob(blob_descriptor, ingestion_properties=ingestion_props)


Overview
--------

*Kusto Python Ingest Client* Library provides the capability to ingest data into Kusto clusters using Python.
It is Python 3.x compatible and supports data types through familiar Python DB API interface.

It's possible to use the library, for instance, from `Jupyter Notebooks <http://jupyter.org/>`_ which are attached to Spark clusters,
including, but not exclusively, `Azure Databricks <https://azure.microsoft.com/en-us/services/databricks>`_ instances.

* `How to install the package <https://github.com/Azure/azure-kusto-python#install>`_.

* `Data ingest sample <https://github.com/Azure/azure-kusto-python/blob/master/azure-kusto-ingest/tests/sample.py>`_.

* `GitHub Repository <https://github.com/Azure/azure-kusto-python/tree/master/azure-kusto-data>`_.
azure-kusto-data 6.0.2
Kusto Data Client
Requires Python: >=3.9
Keywords: azure, kusto, data, analytics

Microsoft Azure Kusto Library for Python
========================================

Overview
--------

.. code-block:: python

    from azure.kusto.data import KustoClient, KustoConnectionStringBuilder

    cluster = "<insert here your cluster name>"
    client_id = "<insert here your AAD application id>"
    client_secret = "<insert here your AAD application key>"
    authority_id = "<insert here your AAD tenant id>"

    kcsb = KustoConnectionStringBuilder.with_aad_application_key_authentication(cluster, client_id, client_secret, authority_id)
    # It is a good practice to re-use the KustoClient instance, as it maintains a pool of connections to the Kusto service.
    # This sample shows how to create a client and close it in the same scope, for demonstration purposes.
    with KustoClient(kcsb) as client:
        db = "Samples"
        query = "StormEvents | take 10"

        response = client.execute(db, query)
        for row in response.primary_results[0]:
            print(row[0], " ", row["EventType"])



*Kusto Python Client* Library provides the capability to query Kusto clusters using Python.
It is Python 3.x compatible and supports
all data types through familiar Python DB API interface.

It's possible to use the library, for instance, from `Jupyter Notebooks
<http://jupyter.org/>`_.
which are attached to Spark clusters,
including, but not exclusively, `Azure Databricks
<https://azure.microsoft.com/en-us/services/databricks/>`_. instances.

Async Client
~~~~~~~~~~~~
Kusto now provides an asynchronous client for queries.

To use the client, first install the package with the "aio" extra:

.. code:: bash

    pip install azure-kusto-data[aio]

The async client uses exact same interface as the regular client, except
that it lives in the ``azure.kusto.data.aio`` namespace, and it returns
``Futures`` you will need to ``await`` its

.. code:: python

    from azure.kusto.data import KustoConnectionStringBuilder
    from azure.kusto.data.aio import KustoClient

    cluster = "<insert here your cluster name>"
    client_id = "<insert here your AAD application id>"
    client_secret = "<insert here your AAD application key>"
    authority_id = "<insert here your AAD tenant id>"


    async def sample():
        kcsb = KustoConnectionStringBuilder.with_aad_application_key_authentication(cluster, client_id, client_secret, authority_id)
        async with KustoClient(kcsb) as client:
            db = "Samples"
            query = "StormEvents | take 10"

            response = await client.execute(db, query)
            for row in response.primary_results[0]:
                print(row[0], " ", row["EventType"])

Links
~~~~~

* `How to install the package <https://github.com/Azure/azure-kusto-python#install>`_.

* `Kusto query sample <https://github.com/Azure/azure-kusto-python/blob/master/azure-kusto-data/tests/sample.py>`_.

* `GitHub Repository <https://github.com/Azure/azure-kusto-python/tree/master/azure-kusto-data>`_.
jims-api 0.5.2
universal API for JIMS application
Requires Python: >=3.12

# jims-api

`jims-api` exposes any JIMS application as a FastAPI HTTP service.


## Run

```bash
jims-api --app my_project.app:app --port 8080
```

Environment variables:

- `JIMS_APP` - JIMS app import path (`module:attr`)
- `JIMS_PORT` - HTTP port
- `JIMS_HOST` - HTTP host
- `JIMS_API_KEY` - optional bearer token for auth

## Endpoints

- `GET /health`
- `POST /api/v1/chat`

### `POST /api/v1/chat`

Request:

```json
{
  "contact_id": "customer:42",
  "message": "Hello",
  "thread_id": null,
  "thread_config": {"interface": "api"},
  "event_type": "comm.user_message",
  "run_conversation_start_on_new_thread": false
}
```

Response:

```json
{
  "thread_id": "0194f0f3-d88d-7cca-8f37-ff44f911f539",
  "created_new_thread": true,
  "assistant_messages": ["Hi! How can I help?"],
  "events": [
    {
      "event_type": "comm.assistant_message",
      "event_data": {"role": "assistant", "content": "Hi! How can I help?"}
    }
  ]
}
```

If `JIMS_API_KEY` is set, send it as `Authorization: Bearer <token>`
jims-core 0.5.2
Add your description here
Requires Python: >=3.12

# Name

JIMS stands for "Just an Integrated Multiagent System"

# Concepts

## Thread

Thread is a conversation between user (or users) and agentic system
Each interaction between agents and users happens in thread

## Event

Something that happens in a thread
Each event has id, type and data

Example:

{
    "event_id": "...",
    "event_type": "comm.user_message",
    "event_data": {
        "content": "Hello!"
    }
}
vedana-etl 0.7.3
Pipeline template for Vedana
Requires Python: >=3.12

# Basic pipeline for all vedana projects.

This pipeline:

- Parses Grist Data & Data Model
- Ensures that Memgraph index/vector index structure is in sync with data model
- Updates Memgraph database in incremental fashion

To add steps:
1. Pass extra transformations to [get_pipeline](src/pipeline.py)
2. Create new app configuration from [app.py](src/app.py)

## Pipeline Labels Hierarchy

### Pipeline

`labels=("pipeline", "pipeline_name")` defines a set of operations as standalone, sort of like a DAG in Airflow
or a Dagster Job. Its purpose is to be able to render it as a separate tab on the ETL page of Backoffice in order to
look at it independently of other transformations

### Stage

`labels=("stage", "stage_name")` defines a stage of `pipeline`. Currently, stages are useful for creating and managing
observability features, such as [main dashboard's](/libs/vedana-backoffice/vedana_backoffice/pages/main_dashboard.py)
Ingest table, which displays DataTable's of all transformations with `labels=("stage", "extract")`.
Stages are also useful when running the pipeline manually.

### Flow

`labels=("flow", "flow_name")` helps execute a `pipeline` (or possibly several pipelines) in a nice fashion,
used in defining cron jobs, etc.