semvec/pypi-packages huggingface dataset:
talos-system-manager 0.1.2
Talos CLI: pip-installable launcher for talos server and UI containers. Run 'talos up' to start Docker stack.
Requires Python: >=3.10

# Talos Usage

Talos is a central control server for ROS2-based robot containers. **Talos CLI** lets you run the server, UI, and Zenoh daemon via Docker.

---

## 1. Installation (Talos CLI)

```bash
# From this repo's talos_cli directory
pip install .

# Or install from wheel (recommended if `talos` command is not found)
python -m build --wheel
pip install dist/talos_cli-0.1.2-py3-none-any.whl

# If published on PyPI
pip install talos-cli
```

**If you see `talos: command not found`**

- With pip user installs, scripts go to `~/.local/bin`. Add it to your PATH:
  ```bash
  export PATH="$HOME/.local/bin:$PATH"
  ```
  (To make it permanent: `echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc`, then open a new terminal.)
- Or run without the script:
  ```bash
  python3 -m talos_cli.cli up
  ```

---

## 2. Basic usage

```bash
talos up
```

- Starts **talos server**, **talos_ui**, and **zenoh daemon** containers in the background.
- Uses the bundled `config/config.yml` by default.
- Requires Docker and `docker compose`.

---

## 3. Options

| Command | Description |
|---------|-------------|
| `talos up` | Start the stack with the packaged default config |
| `talos up -c /path/to/config.yml` | Start with the given config file (creates a copy from the package config if the file does not exist) |
| `talos up --pull` | Pull images before starting |
| `talos down` | Stop talos server, talos_ui, and zenoh daemon |
| `talos --help` | Show help |

---

## 4. Access

- **API**: `http://127.0.0.1:8081`
- **UI**: `http://127.0.0.1:3000` (talos_ui container)

---

## 5. Running from the repo (without CLI)

From the repo root:

```bash
docker compose up -d
```

- Builds `talos/` and `talos_ui`, and uses the root `config.yml` and `docker-compose.yml`.
- Agent sockets are mounted from `/var/run/robotis/agent_sockets`.

---

## 6. Summary

| Goal | Command |
|------|---------|
| Install with pip and run | `pip install ./talos_cli` → `talos up` |
| Stop the stack | `talos down` |
| Run with custom config | `talos up -c ~/myconfig.yml` |
| Pull latest images and run | `talos up --pull` |
| Develop/run from repo | `docker compose up -d` |
TTmTDB 1.0.2
Time difference between the TT and TDB time scales with a precision better han 200ns over 2 centuries.
Requires Python: >=3.8
Keywords: astrometry, astronomy, celestial navigation, mathematics, physics

### NAME
TTmTDB - Difference between the TT and TDB time scale in seconds.

### SYNOPSIS
TTmTDB returns the difference between the TT time scale (terrestrial time, proper time on the earth's geoid at sea level) and the TDB time scale (barycentric dynamical time, taking into account time dilatation in the solar system). Other time scales are connected to TT and TDB via simple scalings but TT-TDB depends on the position of the bodies in the solar system and must be evaluated by ephemeris theories.

TTmTDB tests against INPOP21 with an error of 200ns over 2 centuries (it is in fact used for Inpop unit testing). TTmTDB uses 127 periodic terms given by Fairhead & Bretagnon.

For the past and next centuries the TTmTDB correction has a maximum value of less than 2 ms so it is only required for high precision applications.

#### REQUIREMENTS
TTmTDB depends on Numpy. Numba is not required but will result in a significant speedup.

#### PROVIDES
A single function, TTmTDB.

### DESCRIPTION
The Python module is called ttmtdb:

```python
from ttmtdb import TTmTDB

JD2000 = 2451545.0

dt = TTmTDB(JD2000)
print(dt)
9.930573125973422e-05  # seconds
```
It is possible to pass a second time argument, typically containing a day fraction:

```python
dt2 = TTmTDB(JD2000, 1/12)
print(dt2)
9.689409358933716e-05  # seconds
```

### AUTHOR
TTmTDB is written by Marcel Hesselberth.

### REPORTING BUGS
Online help: https://github.com/hesselberth/TTmTDB/issues

### COPYRIGHT
Marcel Hesselberth.

TTmTDB is released under GPLv3. The text of the license can be found at https://www.gnu.org/licenses/gpl-3.0.txt .
This is free software: you are free to change and redistribute it. There is NO WARRANTY.

### SEE ALSO
Fairhead & Bretagnon (A&A 229, 240-247, 1990).

Inpop: https://github.com/hesselberth/Inpop
use-the-force 0.2.1
Code for practicum Use the Force at Vrije Universteit Amsterdam.
Requires Python: >=3.10

﻿# Use the Force
[![GitHub license](https://img.shields.io/github/license/NatuurkundePracticumAmsterdam/Use-the-Force
)](LICENSE)
[![PyPI - Version](https://img.shields.io/pypi/v/use_the_force)
](https://pypi.org/project/use_the_force/)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/use_the_force)](https://pypi.org/project/use_the_force/)


Python package for physics practicum at Vrije Universiteit Amsterdam.

## Features
Allows for communication with the M5Din Meter that is used within the practicum.\
Comes bundled with a GUI, that includes various settings when using the M5Din Meter.

## Using the GUI
The GUI can be called upon with the `start()` function in `use_the_force.gui`. 

Or by rewriting the `start()` function yourself:
```py
import sys
from PySide6 import QtWidgets
import use_the_force.gui as gui

app = QtWidgets.QApplication(sys.argv)
ui = gui.UserInterface()
ui.show()
ret = app.exec_()
sys.exit(ret)
```

## Additional Info
#### Motorstage speed:
`SV(120)` = 2 mm/s\
`SV(60)` = 1 mm/s

Range: `[1,120]`

## License
Distributed under the MIT License. See [LICENSE](LICENSE) for more information.
ai_nk_cce 0.1.3
This repository is used to train AI agents to predict good strategies in a social learning game based on a NK landscape.
Requires Python: <4.0,>=3.10

# human-ai-social-learning

[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) [![PEP8](https://img.shields.io/badge/code%20style-pep8-orange.svg)](https://www.python.org/dev/peps/pep-0008/)

## Description

## Installation

This project uses Poetry for package management. If you haven't installed Poetry yet, please follow the instructions on the [official Poetry website](https://python-poetry.org/docs/#installation).

To install the project:

1. Clone the repository:

   ```bash
   git clone https://github.com/your-username/human-ai-social-learning.git
   cd human-ai-social-learning
   ```

2. Install dependencies with Poetry:

   ```bash
   poetry install
   ```

3. Activate the virtual environment:

   ```bash
   poetry shell
   ```

4. (Optional) Set up Jupyter kernel for notebooks:

   ```bash
   poetry run python -m ipykernel install --user --name nk-cce-kernel
   ```

Now your development environment is set up and ready to use.

## Contributing

We welcome contributions! Please note:

1. Please create a descriptive branch for each contribution (naming convention *feature_type/feature_name*)
2. Follow the project style (PEP 8 for Python).
3. Add tests and run all before commit. (At least one test per function or method.)
4. Write meaningful commit messages.
5. Keep in line with pre-commit linting.
6. Submit a Pull Request, to include your code into main.

### Pre-commit Hooks

We use pre-commit hooks. Installation:

```bash
poetry add pre-commit
pre-commit install
pre-commit run --all-files
```

### Running Tests

Tests need to be run in the virtual environment. You can use Poetry or Visual Studio Code settings to do so automatically.

To run all tests using Poetry run:

```bash
poetry run pytest
```

We included Visual Studio Code settings in the repository.
You can try to use them to run the tests within Visual Studio Code.

```text
.vscode/
├── settings.json
├── launch.json
```

## Documentation

For an overview of the repository structure, module organization, and
dependencies, see the [Repository Structure Guide](doc/repository_structure.md).

Additional documentation is available in the `doc/` directory:

- [How to compare hill climber vs AI](doc/how_to_compare_hill_climber_vs_ai.md)
- [How to find average hill climber landscape](doc/how_to_find_average_hill_climber_landscape.md)
- [Using MPCDF LLM inference](doc/use_mpcdf_llm_inference.md)
netbox-metatype-importer 0.9.0
Easily import Device and Module types from GitHub repo

# Netbox DeviceType/ModuleType Import Plugin
[NetBox](https://github.com/netbox-community/netbox) plugin for easy import DeviceType and ModuleType from [NetBox Device Type Library](https://github.com/netbox-community/devicetype-library). This is the continuation of the [Netbox DeviceType Import Plugin](https://github.com/k01ek/netbox-devicetype-importer) app.

## Description
The plugin uses [GitHub GraphQL API](https://docs.github.com/en/graphql) to load DeviceType and ModuleType from [NetBox Device Type Library](https://github.com/netbox-community/devicetype-library). The plugin loads only file tree representation from GitHub repo and shows it as a table with vendor and model columns. DeviceType definitions files are loaded when you try to import selected models.
To use GraphQL API you need to set GitHub personal access token in plugin settings. How to create the token, see ["Creating a personal access token."](https://docs.github.com/en/github/authenticating-to-github/creating-a-personal-access-token)

## Compatibility

| NetBox Version | Plugin Version |
|:--------------:|:--------------:|
|     3.4.x      |     0.0.x      |
|     3.5.x      |     0.1.x      |
|     3.6.x      |     0.2.x      |
|     3.7.x      |     0.3.x      |
|     4.0.x      |     0.4.x      |
|     4.1.x      |     0.5.x      |
|     4.2.x      |     0.6.x      |
|     4.3.x      |     0.7.x      |
|     4.4.x      |     0.8.x      |
|     4.5.x      |     0.9.x      |

## Installation

* Install NetBox as per NetBox documentation
* Add to local_requirements.txt:
  * `netbox-metatype-importer`
* Install requirements: `./venv/bin/pip install -r local_requirements.txt`
* Add to PLUGINS in NetBox configuration:
  * `'netbox_metatype_importer',`
* Run migration: `./venv/bin/python netbox/manage.py migrate`

## Configuration

The following options are available in the configuration file:

- `branch`
  - __Type__: `String`
  - __Description__: Branch of the NetBox Device Type Library repo
  - __Default__: `master`
- `github_token`
  - __Type__: `String`
  - __Description__: GitHub personal access token
- `repo`
  - __Type__: `String`
  - __Description__: Name of the NetBox Device Type Library repo
  - __Default__: `devicetype-library`
- `repo_owner`
  - __Type__: `String`
  - __Description__: Owner of the NetBox Device Type Library repo
  - __Default__: `netbox-community`
timeitPro 0.2.3
Advanced Python function profiler with JSON logging and Flask dashboard
Requires Python: >=3.9

# timeitPro

**timeitPro** is an advanced Python function profiler with JSON logging and a Flask dashboard.

## Features

- Decorator `@timeit(runs=N, show_console=True)` to profile functions.
- Measures:
    - Execution time
    - CPU usage (%)
    - Memory usage (bytes)
    - Peak memory (bytes)
- Each run generates a **new JSON log** with incremental filename.
- Flask dashboard:
    - Displays results as **separate line charts** for each metric.
    - Dropdown to select which log file to display.
    - Dropdown to select all run details or only average result.
    - Table with detailed run information.
- Console output optional (`show_console=True/False`).

## Installation

```bash
pip install -r requirements.txt
```

Dependencies:

- Flask
- psutil

## Usage

```python
from timeitPro import timeit, run_dashboard


# Profile a function with 3 runs and console output
@timeit(runs=3, show_console=True)
def my_func():
    total = sum(range(100_000))
    return total


my_func()

# Run the dashboard
run_dashboard()
```

## JSON Logs

- Logs are saved as `timeitPro_log_000001.json`, `timeitPro_log_000002.json`, ...
- Each JSON contains all runs from a profiling session.
- Dashboard automatically lists all available log files.

## Dashboard

- Access via: `http://localhost:5000/`
- Features:
    - Dropdown to select log file
    - Dropdown to select all run details or only average result.
    - Separate line charts for execution time, CPU, memory, peak memory
    - Table of detailed runs

## Dashboard Preview

Here is an example of the timeitPro dashboard report:

![Dashboard Report](https://github.com/farahbakhsh3/timeitPro/blob/main/Images/Report.png)

## License

GNU General Public License v3 (GPLv3)