semvec/pypi-packages huggingface dataset:
julianpy-themeatly2 0.1.5
An API for Julian's Editor
Requires Python: >=3.8

# JulianPy
JulianPy is a API made by Themeatly2 and Harsizcool to interface with Julian's Editor games in a very basic, but efficient way.

## Todo:
- Add basic controls (like keyboard inputs, chat, etc.) -  Done
- Add tools (like hasWifi()) - Done
- Add websocket communication
- Add other things (like Community API, Marketplace API, etc.)

## Example
```
import julianpy
import time

# JulianPy requires a Julian's Editor share link.
# You can get one by clicking the Share icon and then "Copy Link".
id = "https://s.julianseditor.com/3An5lL".replace("https://s.julianseditor.com/", "")
julian = Astronaut(id)
# Move right for 1 second
julian.holdKey("d", 1)
time.sleep(1)
# Send a chat message
julian.sendMessage("Hello from Python!")
time.sleep(3)
# julian.die is required to properly quit the bot, or the bot will stay in the game
# which causes confusion with the server (and even conflicts with other bots) if you try to reconnect.
julian.die()

```
gutentag-world 0.1.3
A simple package that prints 'Gutentag, World!'
Requires Python: >=3.8

# Gutentag, World

`gutentag_world` is a simple Python package that provides a single function to print "Hello, World!" to the console. It's perfect for learning how to create and distribute Python packages.

## Features

- Prints "Gutentag, World!" to the console.

## Installation

You can install the package from the source distribution:

1. Clone or download the repository.
2. Navigate to the package directory where `pyproject.toml` is located.
3. Install the package using pip:

```bash
pip install .
```

## Usage

After installing the package, you can import and use the say_hello function:

```python
from hello_package import say_hello

say_hello()
```

This will output:

```sh
Gutentag, World!
```

## Development

To build and install the package locally for development:

1. Clone the repository.
2. Navigate to the package directory.
3. Install the package in editable mode:

```bash
pip install -e .
```

## Contributing

Contributions are welcome! Here’s how you can help:

1. Fork the repository: Click the “Fork” button at the top of this page.
2. Clone your fork:

```bash
git clone https://github.com/your-username/gutentag_world.git
```

3. Create a new branch

```bash
git checkout -b feature-name
```

4. Make your changes and commit them:

```bash
git add .
git commit -m "Describe your changes"
```

5. Push your changes to your fork:

```bash
git push origin feature-name
```

6. Submit a pull request: Go to the original repository on GitHub and open a pull request.

## Guidelines

- Write clear commit messages.
- Follow PEP 8 style guidelines for Python code.
- Ensure the package builds and works as expected before submitting changes.
- If adding a new feature, update the documentation in this `README.md`.

## License

This project is licensed under the MIT License.

## Author

Sam Gutentag
pytracy 0.0.2
python package for tracing the performance of python code
Requires Python: >=3.11.0

# pytracy

PyTracy is a Python package that enables you to profile your code using the Tracy profiler, a real-time, nanosecond-resolution tool designed for games and applications. With minimal performance overhead, PyTracy integrates seamlessly with your Python code and visualizes profiling results in the Tracy profiler interface.

## Features
- Low overhead: Tracy profiler introduces only 273ns additional overhead per function call, compared to ~62ns for untraced functions. (See the [Performance](#performance) section for more details.)
- Easy integration: PyTracy integrates seamlessly with your Python code, requiring minimal setup to start profiling.
- Multithreading support: Works with multithreaded applications, including full support for free-threaded Python in version 3.13.

## Installation 

Download the pytracy package using the following command:
`pip install pytracy`

You will also need the Tracy profiler to connect to the profiled application. Download it from the  [Tracy Github releases page](https://github.com/wolfpld/tracy/releases/tag/v0.11.1). 
- For Windows, an executable is provided by the author.
- For Linux, you need to build it from the source. Refer to Tracy documentation for build instructions

## Usage
1. Enable profiling in your Python code:
```(python)
import pytracy
pytracy.enable_tracing(True)
```
2. Run your Python script as usual.
3. Open the Tracy profiler and click "Connect" to start profiling.

## Limitations:
- No support for functions run with multiprocessing.

## Performance
PyTracy code impacts the function call and return time, as it has to send those events to the Tracy profiler.
To measure that acurately, the we have to compare the time taken by an empty function and a function with the Tracy profiler enabled. This has been done in the utils/testPer.py.

We have measured 3 cases:
- No profiling, just the function call and return
- Tracy profiling enabled
- Profiling enabled, but the profiler callback is an empty function

The third scenario is used to show the overhead of the Python tracing API itself. The results are as follows:

| Case | Time taken per 20 000 000 calls (s) | Time taken per call (ns) |
| --- | --- | --- |
| No Profiling | 6,721 | 62 |
| Tracy profiling enabled | 1,247 | 336 |
| Empty profiling function | 6,339 | 317 |

The overhead of the Tracy profiler is 273ns per function call (336ns - 62ns), where most of the overhead is due to the Python tracing API itself. The overhead of the Python tracing API is 255ns per function call (317ns - 62ns).

## Goals for 0.3.0 release
- Add Mac support
- Shutdown and startup during program execution
- Allow runtime switching of tracing modes.
- Easy integration with python logging

## Goals for 0.4.0 release
- Offline mode - save trace to file
- Preinitialize all of the code objects, to avoid additional runtime overhead