semvec/pypi-packages huggingface dataset:
gradio-gradioworkbook 0.0.23
Workbook for interacting with models in AIConfig
Requires Python: >=3.8
Keywords: aiconfig,gradio-custom-component,gradio-template-Fallback,notebook,workbook

# gradio_gradioworkbook

A Custom Gradio component to build AI Notebooks powered by AIConfig.

## Example usage

Please see the demo/app.py for full details, but generally all you need to do
is add these lines to your component:

```python
import gradio as gr
from gradio_gradioworkbook import GradioWorkbook

AICONFIG_FILE_PATH = "./example_aiconfig.json" #Can also be empty or None!
with gr.Blocks() as demo:
    GradioWorkbook(filepath=AICONFIG_FILE_PATH)

demo.queue().launch()
```

For the remaining commands for local development, please follow the
instructions from the `README-dev.md` file!
ollamagent 0.0.4
A thin wrapper around `ollama` library
Requires Python: >=3.9,<4.0

# OllamAgent

`OllamAgent` is a wrapper aroundn Ollama API. Ollama is a mini framework for consuming, managing and maintaining SOTA (State of the Art) Large Language Models that have been Quantaized and optimized for deployment on edge devices, there is no need for 'OpenAI' or 'HuggingFace' API keys, or even 'API_KEY' for that matter, you can run these models within your own devices ensuring data privacy, security and most importantly accesibility to this cutting edge technology for people with limited resources.
It implements an Agent | Tools mini-framework that simplifies the ussage of the full set of features of the supported models (Currently only Mistral7B is supported).

## Installation

```bash
pip install ollamagent
```

## Usage

```python
from ollamagent import APIClient, Agent, Tool

# Implementing an integration with a third party API
class MyAPI(APIClient):
	base_url = "https://api.myapi.com"
	headers = {
		"Authorization": "Bearer MY_API_KEY"
	}
 
	async def my_api_method(self, data):
		return await self.post("/my-api-method", data)

# Implementing a tool
class MyTool(Tool):
	data: dict

	@property
	def api(self):
		return MyAPI()
	
	async def run(self):
		return await self.api.my_api_method(self.data)

# Instantiating the agent
agent = Agent(tools=[MyTool])

# Interacting with the agent
async def main():
	print(await agent.chat(message="Hello! Are you there?"))
	>>> "Hello! I'm here, how can I help you?"
	print(await agent.run_tool("MyTool", data={"key": "value"}))
	>>> {"response": "from", "my": "api"}
 
asyncio.run(main())
```
influxql-client 0.0.3
InfluxDB InfluxQL Basic Library
Requires Python: >=3.7
Keywords: InfluxDB,InfluxDB Python Client,InfluxQL

# InfluxDB InfluxQL Client

Temporarily filling in the gap to query influxdb using InfluxQL rather than Flux

Package was created for a specific use case, but will be maintained. PRs welcomed + feature requests welcomed.

## Usage


```python
from influxdb_influxql_client import InfluxQLClient

ic = InfluxQLClient('http://mocked.local:8086', 'database')

# Given this uses requests library, it is possible to update the session to handle basic auth/proxies etc
# For example, disabling SSL verification
ic.sh.verify = False

results = ic.query_api().query("select 1")

for result in results.results:
    for series in result.series:
        print(series.values)

```
invent 0.0.1a2
Invent - an app framework for beginner programmers
Requires Python: >=3.7

# Invent - an app framework for beginners

View this repository
[via GitHub pages](https://invent-framework.github.io/invent/).

This project's documentation can be found
[here](https://invent-framework.rtfd.io).

This project started in 2019 as "PyperCard" ~ a re-implementation of 
[Adafruit's CircuitPython PYOA](https://github.com/adafruit/Adafruit_CircuitPython_PYOA)
module, but for non-CircuitPython computing environments. It was originally
written using the [Kivy](https://kivy.org/) framework for cross-platform
development. After successfully testing PyperCard for teaching and learning
purposes with the wonderful
[young folk](https://youngcodersmeetup.wixsite.com/ycm-uk) at the London
[Young Coders' Meetup](https://twitter.com/YCM_UK), development stalled because
of the COVID pandemic.

The project name has since been changed to "Invent" to remove any HyperCard
related expectations. There are further significant changes:

* [PyScript](https://pyscript.net/) replaces Kivy as the underlying
  cross-platform framework for generating and running the user interface.
* [Nicholas](https://github.com/ntoll), the original developer and maintainer
  of Invent/PyperCard, has been hired by [Anaconda Inc](https://anaconda.com/)
  to work on PyScript, and so his work on this project is sponsored by his
  employer.
* Ownership of the repository has been transferred to the
  [invent framework organisation](https://github.com/invent-framework) on
  GitHub (the old repository will automatically redirect to the new one).
* Since this is a complete rewrite, the license has been changed from MIT
  to Apache2.

All the assets relating to the old version of the project can still be found
in the [old branch](https://github.com/invent-framework/invent/tree/old) in this
repository.

## Developer setup

Git clone the repository:

```
git clone https://github.com/invent-framework/invent.git
```

(Recommended) Upgrade local pip:

```
pip install --upgrade pip
```

Make a virtualenv, then install the requirements:

```
pip install -r requirements.txt
```

Most useful developer related tasks are automated by a `Makefile`:

```
$ make
There's no default Makefile target right now. Try:

make clean - reset the project and remove auto-generated assets.
make tidy - tidy up the code with the 'black' formatter.
make lint - check the code for obvious errors with flake8.
make lint-all - check all code for obvious errors with flake8.
make serve - serve the project at: http://0.0.0.0:8000/
make test - while serving the app, run the test suite in browser.
make dist - build the module as a package.
make publish-test - upload the package to the PyPI test instance.
make publish-live - upload the package to the PyPI LIVE instance.
```

To run the test suite:

```
$ make serve
```

Then visit [http://localhost:8000/](http://localhost:8000/).

The tests should open in your browser, and pass. ;-)

**Please use a width of 79 characters for source code files.**

## Example applications

Coming soon...
pyalic 1.0.1
Licensing system module which allows you to manage access to your products with ease

# Pyalic: Advanced Licensing python module


Install package using `pip` from this GitHub repository

```shell
pip install pyalic
```



## Python example

```python
from pyalic import LicenseManager
import time

lm = LicenseManager("https://LICENSE_SERVER_URL.ORG", ssl_public_key='./trusted_cert.pem')


def my_program():
    print("Access granted!")
    time.sleep(30)


key = input("Enter your license key: ")
check_response = lm.check_key(key)
if check_response.success:
    my_program()
    lm.end_session()
else:
    print("Access denied:", check_response.error)
```
idoc 2.1.8
Individual Drosophila Optogenetics Conditioner
Requires Python: >=3.8.10

# IDOC
Individual Drosophila Optogenetic Conditioner

 * [Introduction](#introduction)
 * [How to do an experiment](#how-to-do-an-experiment)
    * [Open software](#open-software) 
    * [Run software](#run-software) 
    * [Start the experiment](#start-the-experiment)
    * [Browse and understand your results](Browse-and-understand-your-results)
    * [Analyze traces](#analyze-traces)
 * [Make a paradigm](#make-a-paradigm)
 * [Indices](#indices)
  * [Read the logs](#read-the-logs)
 * [Enhancements](#enhancements)

# Install

pip install git+ssh://git@github.com/shaliulab/idoc