semvec/pypi-packages huggingface dataset:
turing-transforms 0.1.0
Utility transform functions for casual data engineer.
License: MIT
Requires Python: >=3.10,<3.13

# Project Set Up Instructions

This document provides step-by-step instructions on how to review this project. The project uses a MySQL database which can be set up locally, using Docker, or hosted in the cloud.

### Prerequisites

- Docker
- Python

### Database Setup

Start by setting up a MySQL database instance. The project is configured to map the database port to a non-default host port, `3311`, to avoid conflicts with any existing local MySQL instances. To set up the MySQL instance using Docker, run the following command:

```bash
docker-compose -f docker/docker-compose.yaml -p "turing" up -d
```

### Insert data

Database is populated using python. Set up an environment. A simple way to do it is using anaconda:

```bash
conda create -n turing python=3.11
```

Activate it:
```bash
conda activate turing
```

Then install dependencies (You can install inside notebook as well):

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

If you are using vscode, you can open it up and select `turing` kernel at the top right of the notebook. If you are using jupyter lab or notebook, you might need to do additional work
to make that new kernel to be available. I recommend using vscode.

This will:
- set up schemas in the database `turing`

## Data storage

Download the data and store inside `data/` folder.

## Solution

The rest of the code is inside `solution` notebook.

## Clean up

After finished reviewing, clean up database by running:

```
docker-compose -f docker/docker-compose.yaml down
```
custom-logger-zhatlebaye 0.1.0
Custom logger
License: MIT
Requires Python: >=3.6

# CustomLogger

A simple Python logging library that logs messages with timestamps and optional coloring for different log levels.

## Features:

- Four log levels: INFO, WARNING, ERROR, DEBUG
- Option to customize the log file name
- Outputs colored logs for a better visual distinction between log levels (only in terminals that support ANSI codes)

## Installation:

```bash
# As of now, you'll need to copy the CustomLogger class into your project since it isn't available as a pip package.

from custom_logger import CustomLogger

# Create an instance of the logger with default log file name (`custom.log`)
logger = CustomLogger()

# Alternatively, specify a log file name:
# logger = CustomLogger(log_file='my_log.log')

# Log messages
logger.log_info("This is an info message.")
logger.log_warning("This is a warning message.")
logger.log_error("This is an error message.")
logger.log_debug("This is a debug message.")


How it works:

When you call any of the logging methods (log_info, log_warning, log_error, log_debug), the message will be appended to the specified log file with a timestamp, log level, and the actual message.

Notes:

The color coding in the logs will appear only when viewing the logs directly in terminals that support ANSI codes. The raw log file will contain the ANSI escape sequences which might appear as gibberish in text editors that do not support them.
Make sure you have the necessary permissions to write to the specified log file.
Contribution:

Feel free to fork and submit pull requests if you wish to contribute to this library.

```
django-vue-utilties 0.1.3
Utilities and helpers for integrating Django + Vue
License: MIT
Requires Python: >=3.7

====================
Django Vue Utilities
====================

Provides helpers and utilities for integrating with a Vue 
front-end, as described in `Cookiecutter Vue + Django`_

.. _Cookiecutter Vue + Django: https://github.com/ilikerobots/cookiecutter-vue-django

Quick start
-----------

1. Add "django_vue_utilities" to your INSTALLED_APPS setting like this:

.. code-block::

    INSTALLED_APPS = [
        ...,
        "django_vue_utilities",
    ]

Usage
-----

Load the template tag in a template. Run the tag with an opening and closing tag.

.. code-block:: django

   {% extends "base.html" %}

   {% load vue_utils %}

   {% block extra_js %}
     {# Import entrypoint JavaScript, choosing dev or static source depending on settings #}
     <script type="module" crossorigin src="{% vue_bundle_url 'my_vue_entrypoint' %}"></script>

     {# 'provide" strings which can 'injected' throughout the Vue app, including from within a pinia store #}
     {% url 'home' as homeUrl %}
     {% vue_provide 'homeUrl' homeUrl %}
   {% endblock %}


Settings
--------

Tailor the following settings to your Vue front-end.  The defaults are provided below.

.. code-block:: django

    VUE_FRONTEND_USE_TYPESCRIPT = False
    VUE_FRONTEND_USE_DEV_SERVER = settings.DEBUG
    VUE_FRONTEND_DEV_SERVER_URL = 'http://localhost:5173'
    VUE_FRONTEND_DEV_SERVER_PATH = 'src'
    VUE_FRONTEND_STATIC_PATH = 'vue'
django-guest-user 0.5.5
A Django app that lets visitors interact with your site without registration.
License: MIT
Requires Python: >=3.8,<4.0

[![Code Lint](https://github.com/julianwachholz/django-guest-user/actions/workflows/lint.yml/badge.svg)](https://github.com/julianwachholz/django-guest-user/actions/workflows/lint.yml)
[![Python Tests](https://github.com/julianwachholz/django-guest-user/actions/workflows/test.yml/badge.svg)](https://github.com/julianwachholz/django-guest-user/actions/workflows/test.yml)
[![Documentation](https://readthedocs.org/projects/django-guest-user/badge/?style=flat)](https://django-guest-user.readthedocs.io)

# django-guest-user

Allow visitors to interact with your site like a temporary user ("guest")
without requiring registration.

Anonymous visitors who request a decorated page get a real temporary user object
assigned and are logged in automatically. They can use the site like a normal
user until they decide to convert to a real user account to save their data.

Inspired by and as an alternative for [django-lazysignup](https://github.com/danfairs/django-lazysignup)
and rewritten for Django 3.2+ and Python 3.8+.

## Documentation

Find the [**complete documentation**](https://django-guest-user.readthedocs.io/)
on Read the Docs.

## Quickstart

1. Install the `django-guest-user` package from PyPI
2. Add `guest_user` to your `INSTALLED_APPS` and migrate your database
3. Add `guest_user.backends.GuestBackend` to your `AUTHENTICATION_BACKENDS`
4. Include `guest_user.urls` in your URLs
5. Decorate your views with `@allow_guest_user`:

   ```python
   from guest_user.decorators import allow_guest_user

   @allow_guest_user
   def my_view(request):
       assert request.user.is_authenticated
       return render(request, "my_view.html")
   ```

A more detailed guide is available in the
[installation documentation](https://django-guest-user.readthedocs.io/en/latest/setup.html#how-to-install).

## Contributing

All contributions are welcome! Please read the
[contributing guidelines](CONTRIBUTING.md) in this repostory.

## Development Status

This project is under active development. Thanks to
[previous work](https://github.com/danfairs/django-lazysignup) the core
functionality is well-established and this package builds on top of it.

This project was created because the original project has been in an inactive
state without major updates in a long time. The code base was rewritten with
only modern versions of Python and Django in mind.