semvec/pypi-packages huggingface dataset:
dfanalyzer 0.0.4
Pyspark Dataframe Analyzer - Smartest DataFrame Analysis
Keywords: python,pyspark,spark,ingestion,data,dataframe,analysis,schema,pandas


# DFAnalyzer 


DFAnalyzer Python is a Python package for data analysis, built on top of the popular DFAnalyzer for Excel. It provides a powerful set of tools for importing, exploring, cleaning, transforming, and visualizing data. It also offers features such as filtering, sorting, grouping, and performing calculations on data. DFAnalyzer Python is designed to enable users to quickly and easily analyze large amounts of data and **extract meaningful insights.**

* Find details & insight about each columns.
* Easy to perform cycles over pyspark.
* Percentage stats around NaN , Blank Values, Null Values.
* Describes datatypes of Pyspark Dataframe.
* Help in POC of data.



## Who Should use DFAnalyser

* Developers working with bigdata
* Developers using pyspark in the Data exploration.
* Developers who needs to do poc over raw data.




## Usage

### PySpark 

You can install the DFAnalyzer package using the pip command. To install DFAnalyzer, open a terminal window and type: pip install dfanalyzer. Once the installation is complete, you can start using DFAnalyzer with Python.

1. Install the preset:

    ```sh
    pip install dfanalyzer
    ```

2. Import it:

    ```diff
    import DFAnalyzer as dfa
    ```

3. Use it on existing pyspark dataframe:

    ```python
      #[isHavingNullData,%NullData,isHavingNanValues,%NanValues,isHavingBlankValues,%BlankValues,DataType]
      options=[1,1,1,1,1,1,1]#flags of what all kind of analysis you need
      dfa.analyze(df,options)

    ```
>More is about to come. Stay tuned.
smallexpimv 0.0.1
A package to apply the imaginary exponential of a small-dimensional matrix to a vector.
Requires Python: >=3.7
Keywords: matrix-exponential

# smallexpimv
This repository provides some Fortran routines and python wrappers to apply the imaginary exponential of a matrix (real tridiagonal or complex) to a vector. More precisely,

$$
\beta\mathrm{e}^{\pm\mathrm{i} t X} u \in\mathbb{C}^n,
$$

for a matrix $X\in\mathbb{C}^{n\times n}$, a time-step $t\in\mathbb{R}$, a scaling factor $\beta\in\mathbb{R}$, a vector $u\in\mathbb{C}^n$ and the imaginary number $\mathrm{i}^2 = -1 $. Our first routine computes this vector by an adaptive and restarted Taylor approximation. We also provide a second routine for a tridiagonal case, namely

$$
\beta\mathrm{e}^{\pm\mathrm{i} t T} e_1 \in\mathbb{C}^n,
$$

where $T\in\mathbb{R}^{n\times n}$ refers to a tridiagonal symmetric matrix and $e_1$ denotes the first unit vector, i.e., $e_1 = (1,0,\ldots,0)^\ast \in\mathbb{R}^{n}$. For the tridiagonal case, the action of the matrix exponential is computed using an eigendecomposition of $T$ via the lapack $\texttt{dstevr}$ routine.

The matrix exponentials above have some relevance for the Lanczos or Arnoldi approximations to the action of large-dimensional matrix exponentials, e.g., for time-dependent Schrödinger-type problems. In this context, $X$ or $T$ correspond to small dimensional Krylov representations of a large problem.

The main code is written in Fortran, and can be used in Python using f2py.

To generate the main python module smallexpimv.so run
> python3 -m numpy.f2py -c src/F_smallexpimv.F90 -m smallexpimv -lblas

optional, generate f2py header files:
> python3 -m numpy.f2py -h smexp.pyf -m smallexpimv src/F_smallexpimv.F90

For more user-friendly Python code which also handles working memory (most relevant when applying the matrix exponential multiple times)
we also provide the module smallexpimv_pyclass.py. Keep in mind that this module requires still the smallexpimv.so module.

makefile: run
> make test

to run the python and fortran tests, and
> make libs

to generate smallexpimv.so and smallexpimv_pyclass.pyc. To use the Makefile, first check that (in the makefile) the compiler commands and the f2py filename extension are defined correctly for your system!


python3.7 -m build --sdist
python3.7 -m twine upload --repository testpypi dist/*
python3.7 -m pip install --index-url https://test.pypi.org/simple/ --no-deps mypackagetjx

python3.7 -m pip install mypackagetjx==0.0.14 --extra-index-url=https://test.pypi.org/simple/

from mypackagetjx import onef
cloudshare 0.1.3
A python wrapper for the CloudShare REST API.
Requires Python: >=3.6
Keywords: cloudshare,cloud,SDK,REST,API

CloudShare API v3 SDK
=====================
Quickstart
----------
`pip install cloudshare`


Then just `import cloudshare` and use the function `cloudshare.req()` described below.


Interface
---------
This library is written for python 3.

```
def req(hostname, method, apiId, apiKey, path="", queryParams=None, content=None)
```
Required parameters are the `hostname`, `method`, `apiId` and `apiKey`.

`hostname` is usually `use.cloudshare.com` unless your using some mock or proxy.

`method` is one of "GET", "POST", "PUT", "DELETE", depends on the context of the call.

`apiId` and `apiKey` are valid CloudShare credentials.

`path` is what comes after the `'/api/v3'` part of the request url (e.g `'envs'`, `'vms/actions/executePath'`)

`queryParams` are a dict of values that translate to a query string and concatenated to the request url

`content` is a dict that's encoded to JSON and sent in the body section of the request, in POST and PUT requests.

Examples
--------
#### example.py
Enter your credentials in the two global variables `API_ID` and `API_KEY` and run it with `python example.py`. The script tries to run the command `echo hello world` on the first machine on the first environment it finds (visible to the user's credentials).

#### List your environments
```
import cloudshare
res = cloudshare.req(hostname='use.cloudshare.com',
				method='GET',
				path='envs',
				apiId='Your API ID',
				apiKey='You API Key')
if (res.status / 100 != 2):
	raise Exception(res.status, res.content)
print 'hi! these are my environments:'
print [e['name'] for e in res.content]
```

#### Get one environment
```
import cloudshare
res = cloudshare.req(hostname='use.cloudshare.com',
				method='GET',
				path='envs/' + envId,
				apiId='Your API ID',
				apiKey='You API Key')
if (res.status / 100 != 2):
	raise Exception(res.status, res.content)
print 'look at my environment details:'
print res.content
```

#### Suspend an environment
```
import cloudshare
res = cloudshare.req(hostname='use.cloudshare.com',
				method='PUT',
				path='envs/actions/suspend',
				queryParams={'envId': envId},
				apiId='Your API ID',
				apiKey='Your API Key')
if (res.status / 100 != 2):
	raise Exception(res.content)
print res.content
```

## Building from source

```
make setup
make build test
```


## Let's Encrypt Certificates
You might need to install these root certificates if they were not updated by the OS

https://letsencrypt.org/certs/isrgrootx1.der

https://letsencrypt.org/certs/isrg-root-x2.der

https://letsencrypt.org/certs/lets-encrypt-r3.der


More info here:

https://letsencrypt.org/certificates/