semvec/pypi-packages huggingface dataset:
django-hide 0.0.4.1
A Django package to obscure Django applications from detection tools like Wappalyzer by encrypting the CSRF token.
Requires Python: >=3.8
Keywords: django security wappalyzer hide csrf

# Django Hide

![Django CI](https://github.com/metemaddar/django_hide/actions/workflows/django.yml/badge.svg)

<p align="center">
  <img src="https://raw.githubusercontent.com/metemaddar/django_hide/master/docs/logo.svg" alt="Logo"/>
</p>

**Django Hide** is a Django package designed to obscure your application's programming languages and frameworks from detection tools like Wappalyzer. By encrypting the CSRF token tag, this package helps prevent Wappalyzer and similar tools from identifying your application as a Django project.

## Requirements

### Python
Supports Python versions 3.6 and later, in line with Django’s compatibility. For more details on Python versions compatible with Django, see [What Python version can I use with Django?](https://docs.djangoproject.com/en/stable/faq/install/#what-python-can-i-use-with-django)

## Installation

Install `django-hide` and its dependencies from [PyPI](https://pypi.python.org/pypi/django-hide) using `pip`:

```shell
pip install django-hide
```

## Setup

1. Add `django_hide` to your `INSTALLED_APPS`:

    ```python
    INSTALLED_APPS = (
        ...
        'django_hide',
    )
    ```

2. Add `django_hide` middleware to your `MIDDLEWARE`:

    ```python
    MIDDLEWARE = (
        ...
        'django_hide.middleware.CSRFHIDEMiddleware',
    )
    ```

3. Load the `{% load django_hide %}` template tag in your templates:

    ```html
    {% extends "base.html" %}
    {% load django_hide %}
    ```

4. Replace `{% csrf_token %}` with `{% h_csrf_token %}` in your forms:

    ```html
    <form method="post" action="{% url 'action' %}" 
          onsubmit="return confirm('Are you sure?')">
        
        {% h_csrf_token %}

        <button class="btn btn-sm btn-warning"
                type="submit">{% "Submit" %}</button>
    </form>
    ```

## Note

To ensure your Django application remains hidden, clear Wappalyzer cookies.
esi-ui 0.1.0
A panel plugin for OpenStack Dashboard

esi-ui
======

OpenStack Horizon plugin that supports ESI

Installation
------------

Clone the repository::

        git clone https://github.com/CCI-MOC/esi-ui.git

Copy all files under esi-ui's ``enabled`` directory::

        cp -r <esi-ui path>/esi_ui/enabled <horizon path>/openstack_dashboard/local

Next, install the package into the environment you use to run your server.

If you run Horizon using tox, edit your tox.ini file to include esi-ui as a dependency::
        
        [testenv]
        deps = 
          ...
          -r{toxinidir}/requirements.txt
          -e <esi-ui path>

Then restart your server by running::

        tox -e runserver_plus -- localhost:8000

Read how to install Horizon to use tox here: https://github.com/CCI-MOC/esi/issues/545#issuecomment-2143063522

_______________________________________________

If you run Horizon using Apache, pip install the esi-ui package::
    
        python setup.py sdist
        pip install dist/<package>.tar.gz

Finally, restart your server using one of the commands based on your environment from here: https://docs.openstack.org/horizon/latest/install/, 

Read more about general plugin installation: https://docs.openstack.org/horizon/latest/contributor/tutorials/plugin.html#installing-your-plugin

Structure
---------

An example file structure looks like this::

        esi_ui
        ├── api
        │   ├── esi_api.py
        │   ├── esi_rest_api.py
        │   └── __init__.py
        ├── content
        │   ├── esi
        │   │   ├── __init__.py
        │   │   ├── panel.py
        │   │   ├── templates
        │   │   │   └── esi
        │   │   │       └── index.html
        │   │   ├── urls.py
        │   │   └── views.py
        │   └── __init__.py
        ├── enabled
        │   ├── _6000_esi_panel_group.py
        │   └── _6010_project_nodes_panel.py
        ├── __init__.py
        └── static
            └── dashboard
                └── project
                    └── esi
                        ├── esi.controller.js
                        ├── esi.html
                        ├── esi.module.js
                        └── nodes.service.js


api
---
esi_rest_api.py contains api endpoints that becomes registered on the server. This file usually calls functions defined in esi_api.py which usually returns resources such as nodes, leases, offers, etc.

content
-------
This directory holds subdirectories that contain the content required to display a panel.

enabled
-------
This directory contains files that define settings for dashboards, panels, panel groups, and Django.

static
------
This directory and its contents will be copied to the Horizon root directory for Angularjs to see. To add to different dashboards, such as admin or identity, create a directory under dashboard and populate it with your Angularjs files.

Read more about the file structure: https://docs.openstack.org/horizon/latest/contributor/tutorials/plugin.html#file-structure
gcloud-tasks-emulator 0.6.2
A stub emulator for the Google Cloud Tasks API
Requires Python: >=3.7
Keywords: Google Cloud Tasks, Google App Engine, GAE, GCP

# Local Emulator for Google Cloud Tasks

Google doesn't (yet) ship an emulator for the Cloud Tasks API like they do for
Cloud Datastore.

This is a stub emulator so you can run your tests and do local development without
having to connect to the production Tasks API.

**THIS IS A WORK IN PROGRESS NOT ALL API CALLS ARE COMPLETE**

---

## Looking for Commercial Support?

Potato offers Commercial Support for all its Open Source projects and we can tailor a support package to your needs.

If you're interested in commercial support, training, or consultancy then go ahead and contact us at [opensource@potatolondon.com](mailto:opensource@potatolondon.com)

---

## Usage

Start the emulator with:

```
gcloud-tasks-emulator start --port=9090
```

Then from within your code, use the following (instead of your normal production client connection)

### Python

```py
import grpc
from google.cloud.tasks_v2 import CloudTasksClient
from google.cloud.tasks_v2.services.cloud_tasks.transports import CloudTasksGrpcTransport

client = CloudTasksClient(
    transport=CloudTasksGrpcTransport(channel=grpc.insecure_channel("127.0.0.1:9090"))
)
```

### Node.js

```js
const grpc = require("@grpc/grpc-js");
const { CloudTasksClient } = require('@google-cloud/tasks');

const client = new CloudTasksClient({
    servicePath: "localhost",
    port: 9090,
    sslCreds: grpc.credentials.createInsecure()
});
```

### Java

```java
import com.google.api.gax.core.NoCredentialsProvider;
import com.google.api.gax.grpc.InstantiatingGrpcChannelProvider;
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.CloudTasksSettings;
import io.grpc.ManagedChannelBuilder;

CloudTasksSettings settings = CloudTasksSettings.newBuilder()
        .setCredentialsProvider(NoCredentialsProvider.create())
        .setTransportChannelProvider(
                InstantiatingGrpcChannelProvider.newBuilder()
                        .setEndpoint("localhost:9090")
                        .setChannelConfigurator(ManagedChannelBuilder::usePlaintext)
                        .build()
        )
        .build();
CloudTasksClient client = CloudTasksClient.create(settings);
```

## The 'default' queue

By default, the emulator won't create a 'default' queue, however you can enable this
by passing the fully-qualified name of the queue:

```
gcloud-tasks-emulator start --default-queue=projects/[PROJECT]/locations/[LOCATION]/queues/default
```

## Specifying a queue.yaml

If your project uses a queue.yaml file, you can create default queues by passing its path to the `--queue-yaml` argument.

Additionally, you'll likely want to pass `--queue-yaml-project` and `--queue-yaml-location` to generate the correct
fully qualified queue names. These settings will otherwise default to `"[PROJECT]"` and `"[LOCATION]"` respectively.

## Specifying a target

Task queue needs to point at a service for outgoing requests. You can specify this with `--target-host` and `--target-port`

## Testing
Run:
```
python gcloud_tasks_emulator/tests.py
```