semvec/pypi-packages huggingface dataset:
nlScript-microscope-language 0.3.0
Use nlScript to develop a language based on natural English syntax to control microscope acquisition pipelines.
Requires Python: >=3.10

# nlScript microscope language

A natural language for configuring complex microscope timelapse experiments, based on nlScript.

Even on modern microscopes, time-lapse experiments are often limited to data acquisition at fixed intervals. At each time point, images are acquired at a fixed number of planes, at fixed stage positions, possibly repeated for a fixed set of channels. The dynamic nature of biological processes often requires a more flexible imaging pipeline to be observed optimally, e.g., with the imaging interval adapted to the rate of change, with different channels imaged at varying intervals, or with different positions imaged with varying magnification. The hardware of modern microscope allows for such a flexibility, the limiting factor is the software. The reasons for this is the effort needed to design and develop a user interface that is intuitive and yet allows to configure such a flexible imaging experiment.

To address this gap, we have developed a language for describing flexible time-lapse imaging experiments on microscopes. While our language has been developed for the Zeiss Celldiscoverer 7, it is easily adaptable to other microscope modalities. Remarkably, only a few sentence templates are sufficient to configure time-lapse experiments that (i) provide flexible intervals, (ii) select positions and channels at each time point, (iii) adopt magnification, (iv) adopt channel settings such as laser power, (v) provide adjustable environmental settings (temperature and CO2 concentration).

More information about how to use nlScript to develop custom natural language interfaces can be found here:
- https://nlScript.github.io/nlScript-java
- https://github.com/nlScript/nlScript-java

You can interactively try the language at https://nlScript.github.io/nlScript-microscope-language-js.

## Installation

- Install Python >=3.10 (including pip and venv)

- Optional: create a virtual environment:
  ```bash
  cd path/to/this/repository-folder
  python -m venv env
  ```

- If you created a virtual environment, activate it. On Windows, using Git Bash, e.g.
  ```
  source env/Scripts/activate
  ```

- Install nlScript-microscope-language:
  ```
  pip install nlScript-microscope-language
  ```

- Run it:
  ```
  nlScript-microscope-language 
  ```


## License

This project is licensed under the MIT License - see the [LICENSE.txt](LICENSE.txt) file for details.
grant-funding-assistant 0.4
This is a multiagent system which can help researchers create grant funding proposals based on their research profile and funding guidelines
Requires Python: >=3.10


----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

# Grant funding assistant

![Grant funding assistant](https://raw.githubusercontent.com/Dorcatz123/grant_funding_assistant/main/joyful_bots_collaborating.jpg)

## Overview


GitHub link: [Link](https://github.com/Dorcatz123/grant_funding_assistant)

## Features
- **Easy input**: The program will let researchers easily input their details such as name, google scholar link, websites, funding opportunity etc and will 
                   help create a fantastic research proposal based on the rules specified at the funding website.
- **Agents**: All the heavy research tasks are done by multiple well crafted agents which work synchronously to write a fantastic research proposal. 

## Technologies Used
- **Python**: The primary programming language used for developing the assistant.
- **Crew.ai**: Using crew.ai to build carefully crafted agents to do various taks synchronously to accomplish the goal of writing a research proposal.


## User installation
To run the grant funding assistant locally, follow these steps:

   ```bash
  pip install --upgrade grant_funding_assistant
   ```

## Running the Chatbot
To start the assistant run the following command in terminal:
```bash
grant_funding_assistant
```


## Contributing
Contributions are welcome! If you have suggestions for improvements or features, create a pull request or open an issue in the GitHub page.

## License
This project is licensed under the MIT License. See the [LICENSE](LICENSE.txt) file for details.


## History of the grant funding assistant

The grant funding assistant project was initiated by Akshay PR (2024) with the goal of providing an AI-powered assistant to help researchers to create succesful grant funding proposals
based on the grant funding criteria. 


### Key Milestones:
- **[10 2024]**: Initial concept and prototype developed.


As we bring in more contributors, the project remains rooted in its mission to provide accessible and reliable information backed by links to the source documents.


## Contact
For any inquiries or feedback, please contact Kiran or Akshay: [Akshay P R](mailto:akshaypr314159@gmail.com)

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------
taskiq-asyncpg 0.3.2
Asyncpg and PostgreSQL integration for taskiq
Requires Python: >=3.9
Keywords: async, asyncpg, distributed, postgresql, result_backend, taskiq, tasks

# TaskIQ - Asyncpg

TaskIQ-Asyncpg is a plugin for taskiq that adds a new result backend based on PostgreSQL and [Asyncpg](https://github.com/MagicStack/asyncpg).

## Installation
To use this project you must have installed core taskiq library:
```bash
pip install taskiq
```

This project can be installed using pip:
```bash
pip install taskiq-asyncpg
```

using poetry:
```bash
poetry add taskiq-asyncpg
```

using rye:
```bash
rye add taskiq-asyncpg
```

## Usage
Let's see the example with the redis broker and PostgreSQL Asyncpg result backend:
```python
# broker.py
import asyncio

from taskiq_redis import ListQueueBroker
from taskiq_asyncpg import AsyncpgResultBackend

asyncpg_result_backend = AsyncpgResultBackend(
    dsn="postgres://postgres:postgres@localhost:5432/postgres",
)

# Or you can use PubSubBroker if you need broadcasting
broker = ListQueueBroker(
    url="redis://localhost:6379",
    result_backend=asyncpg_result_backend,
)


@broker.task
async def best_task_ever() -> None:
    """Solve all problems in the world."""
    await asyncio.sleep(5.5)
    print("All problems are solved!")


async def main():
    await broker.startup()
    task = await best_task_ever.kiq()
    print(await task.wait_result())
    await broker.shutdown()


if __name__ == "__main__":
    asyncio.run(main())
```

## AsyncpgResultBackend configuration
- `dsn`: connection string to PostgreSQL.
- `keep_results`: flag to not remove results from Redis after reading.
- `table_name`: name of the table in PostgreSQL to store TaskIQ results.
- `field_for_task_id`: type of a field for `task_id`, you may need it if you want to have length of task_id more than 255 symbols.
- `serializer`: type of `TaskiqAsyncpgSerializer` default is `PickleSerializer`
- `**connect_kwargs`: additional connection parameters, you can read more about it in [Asyncpg](https://github.com/qaspen-python/asyncpg) repository.