semvec/pypi-packages huggingface dataset:
delta-table-utils 0.0.17
Delta table utilities.
Requires Python: >=3.8

# delta_table_utils

Delta table utilities.

The basic use case for this library is if you are working in Databricks and want to do upserts using [AutoLoader](https://docs.databricks.com/ingestion/auto-loader/index.html).

Basic usage:

```python
from delta_table.delta_table_utils import DeltaTableColumn, DeltaTable

schema_name = 'my_schema'
table_name = 'my_table'

# Define the delta table schema
column_list = [
    DeltaTableColumn('id', data_type='STRING', nulls_allowed=False, is_unique_id=True),
    DeltaTableColumn('col1', data_type='STRING', nulls_allowed=False),
    DeltaTableColumn('col2', data_type='DOUBLE'),
    DeltaTableColumn('col3', data_type='DOUBLE'),
    DeltaTableColumn('col4', data_type='DOUBLE'),
    DeltaTableColumn('created_at', data_type='TIMESTAMP'),
    DeltaTableColumn('updated_at', data_type='TIMESTAMP')
]

# Create the DeltaTable object
delta_table = DeltaTable(schema_name=schema_name, table_name=table_name, upload_path="<location_of_data_in_s3>", column_list=column_list)

# Create the table and start the stream
delta_table.create_if_not_exists(sqlContext)
delta_table.stream(spark, cloudFiles_format='csv')
```

## Additional notes

By default, when you use the `stream` method in this library, it stops as soon as no new data is detected. This is useful if you don't want a cluster running all the time and rather you just want to update your delta tables on some sort of a schedule.
karel-the-robot 1.1.1
Unofficial port of Karel the Robot to Python

# Please click [here](https://cjbell630.github.io/Karel_the_Robot-Python) for documentation! ##
Alternatively, the raw HTML file can be found in [/karel_the_robot/docs/karel_the_robot-doc.html](/karel_the_robot/docs/karel_the_robot-doc.html).

##
## Installing and Importing
**Karel the Robot is now on PyPi!!!**

To install, run:

>
    pip install karel_the_robot

Some IDEs (such as PyCharm) might be able to automatically run this command if you type the import sequence.

Additionally, when using [repl.it](https://repl.it/), you may have to import manually.
To do so, follow these steps within your repl:

* Click the "Packages" tab
* Search for and select "karel-the-robot" (dashes instead of underscores)
* Press the plus (+) symbol by the package name

<br>

Once installed, the recommended way to import is:

>
    from karel_the_robot import World, Robot

Of course, there are numerous other ways to import.
#

***All credit to the concept and ideas belong to the original Karel team (made in Java). This is a PORT, not an original creation by any means.***
srequests 0.0.3
A package for taking requests from a Scratch project.
Requires Python: >=3.7

# srequests

## A package for taking requests from a Scratch project

![PyPI Version](https://img.shields.io/pypi/v/srequests?style=for-the-badge) ![Forks](https://img.shields.io/github/forks/heyimocto/srequests?style=for-the-badge)  ![License](https://img.shields.io/github/license/heyimocto/srequests?style=for-the-badge)

## Documentation

For making a project, open [this project](https://scratch.mit.edu/projects/759181792/) and backpack the main sprite

## Connect to a project

To connect to a project, import the library and connect to a project with your credentials.

```py
from srequests import srequests

sr = srequests.SRequests("Username","Pass","ProjectID")
```

## Check if request is unanswered

To check if there is an unanswered request, use `Request.IsPending()`.

```py
if sr.Request.IsPending():
    print("Request unanswered!")
```

## Respond to a request

To reply, use the function `Request.Respond()`.

```py
if sr.Request.IsPending():
    sr.Request.Respond("Response")
```

## Get request data

To get the request info & content, use `Request.GetName()` and `Request.GetContent()`.

```py
name = sr.Request.GetName()
content = sr.Request.GetContent()
```

## Get user info (new in 0.0.3)

You can also get info of the user that sent the request.

To get the user's name you can use the `Request.User.GetName()` function, which returns the name of the user.

To get more user info , you can also use the `Request.User.GetData()` function.

### Attributes of GetData

```py
user.join_date
user.about_me
user.wiwo
user.country
user.icon_url
```
python-xray 0.3.1
Python-xray converts Xray commands into python3 methods making it very easy to use xray in any of your python pentesting projects
Requires Python: >=3.6

# python-xray

A python 3 library which helps in using chaitin's community xray web scanner. This tool convert command line into python functions. 

For example in xray if you want to scan for url `http://xxx.xx/` you would to something like this
```bash
./xray_linux_amd64 --config ./configs/config.yaml webscan url http://xxx.xx/
```

But in this python-xray script you would do something like this
```python
import pyxray

# xray = pyxray.XrayWebScanner(['/path/to/your/xray-software-dir/xray_linux_amd64'])
xray = pyxray.XrayWebScanner()  # default: find it from your PATH
res = xray.webscan(urls=['http://xxx.xx/'])
res = xray.webscan_with_crawler(urls=['http://xxx.xx/'])

print(res)
```
> NOTE: xray_search_path must be an iterable object
hangePointDetectorEVT 0.0.18
This module takes a date time series and returns: (a) the underlaying linear trend and (b) the times where there is a change in the trend
Requires Python: >=3.7
Keywords: Time Series, Anomaly, Detection, Kalman, EVT

ChangePointDetector

This module returns change points in a date time series, using Kalman filters and EVT as described in https://www.robots.ox.ac.uk/~sjrob/Pubs/LeeRoberts_EVT.pdf

1. from ChangePointDetector import ChangePointDetector
2. Prepare your time series as data plus Panda dates
3. Create  the necessary Kalman representation by creating a "session" object by calling the ChangePoint class, e.g.:
	Session=ChangePointDetector.ChangePointDetectorSession(data,dates). 
	- 'SeasonalityPeriods' is an optional input, e.g if your data is sequential months, 12 = calendar month seasonality
	- 'ForecastPeriods' is another optional input, indicating how many periods to forecast.  Default = 3
4. Determine the changepoints by running the ChangePointDetectorFunction on your "session", e.g. Results=Session.ChangePointDetectorFunction()
   This will return a "Results" object that contains the following:
	- ChangePoints. This is a list of 0s and 1s the length of the data, where 1s represent changepoints
	- Prediction. This is the Kalman smoothed actuals, plus a 3 period forecast. Note no forecast will be made if there is a changepoint in the last 3 			dates
	- PredictionVariance.  Variance of the smoothed actuals and forecast
	- ExtendedDates. These are the original dates plus 3 exta for the forecast (if a forecast has been made)
	- Trend. This is the linear change factor
	- TrendVariance. Variance of the trend
django_json_logging 0.0.7
Various JSON logging extensions for the Django Framework
Requires Python: >=3.8

# django_json_logging
Various JSON logging extensions for the Django Framework

[![PyPI Version][pypi-image]][pypi-url]

[pypi-image]: https://img.shields.io/pypi/v/django_json_logging
[pypi-url]: https://pypi.org/project/django_json_logging/

# Installation

Using pip

`pip install django_json_logging`

Using pipenv

`pipenv install django_json_logging`

# Quick start
In your project’s `settings.py` add `AccessLogMiddleware` to `MIDDLEWARE` and add `JSONFormatter` to `LOGGING`.

```
MIDDLEWARE = [
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.locale.LocaleMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    ...
    'django_json_logging.middleware.AccessLogMiddleware',
]
```
``` 
LOGGING = {
    ...
    'formatters': {"json": {'()': 'django_json_logging.logging.JSONFormatter'}},
    ...
}
```