semvec/pypi-packages huggingface dataset:
smms-cascades 1.0.3
A command line HTTP client to of https://sm.ms
Requires Python: >=3.6

# smms-cli

![PyPI](https://img.shields.io/pypi/v/smms-cascades)
![PyPI - License](https://img.shields.io/pypi/l/smms-cascades)

A command line HTTP client of <https://sm.ms>

## Usage

```python=
$ smms -h
usage: smms [-h] [-f FILENAME] [-o OUTPUT] method

A simple command line HTTP client of https://sm.ms

positional arguments:
  method                API method: [upload | delete | getprofile | gethistory]

optional arguments:
  -h, --help            show this help message and exit
  -f FILENAME, --filename FILENAME
                        used with [upload | delete], select image to be uploaded or deleted
  -o OUTPUT, --output OUTPUT
                        used with upload, specify the output format: [json | md | url], default is json
```

## Links

* API Docs: <https://doc.sm.ms/#api>
* My blog: <https://cascadeschen.cn/2022-03-28-smms-cli/>
UzbekStemmer 0.2.6
Uzbek Stemmer for Python
Requires Python: >=3.9

**UzbekStemmer**

version = 0.2.6

authors = [Maksud Sharipov, Ulugbek Salaev, Allabergan Yuldashev, Jasur Sobirov]

Uzbek Stemmer for Python

The Uzbek stemming algorithm was created by [Maksud Sharipov, Ulugbek Salaev, Allabergan Yuldashev, Jasur Sobirov]. It stems all Uzbek words and it is not included any lexicon.

github url: https://github.com/MaksudSharipov/UzbekStemmer

pypi.org url: https://pypi.org/project/UzbekStemmer/

<code>pip install UzbekStemmer</code>
```
Example:
from UzbekStemmer import UzbekStemmer as uzstem
print(uzstem.UzStemmer('Bolalarimizdanmisizlar'))

Result: "Bola"
```
r2-LatestEarthquake 0.2
This package will get the latest earthquake from BMKG
Requires Python: >=3.6

# Latest Earthquake in Indonesia
Latest Earthquake Indonesia from Indonesian Agency for Meteorology, Climatology, and Geophysics (BMKG)

## ABOUT
This Package will scrape from [BMKG](https://www.bmkg.go.id/) to get latest earthquake in Indonesia.

Using Library BeautifulSoup4 and Request, to produce output in the form of JSON that is ready to be used in web or mobile apps.
tcs-shellWhat 1.5.0
Submission correctness tests for shell languages

shellwhat
=========

[![Build Status](https://travis-ci.org/datacamp/shellwhat.svg?branch=master)](https://travis-ci.org/datacamp/shellwhat)
[![codecov](https://codecov.io/gh/datacamp/shellwhat/branch/master/graph/badge.svg)](https://codecov.io/gh/datacamp/shellwhat)
[![PyPI version](https://badge.fury.io/py/shellwhat.svg)](https://badge.fury.io/py/shellwhat)
[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fdatacamp%2Fshellwhat.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fdatacamp%2Fshellwhat?ref=badge_shield)

`shellwhat` enables you to write Submission Correctness Tests (SCTs) for interactive Shell exercises on DataCamp.

- If you are new to teaching on DataCamp, check out https://instructor-support.datacamp.com.
- If you want to learn what SCTs are and how they work, visit [this article](https://instructor-support.datacamp.com/courses/course-development/submission-correctness-tests) specifically.
- For a complete overview of all functionality inside `shellwhat` and articles about what to use when, consult https://shellwhat.readthedocs.io.

Installing
----------

```bash
pip install shellwhat
```

Development
-----------

Install everything needed for developing:

```bash
pip install -r requirements.txt
pip install -e .
```

By default, the `DummyParser` is used, that does not parse the shell code.
Hence, you can not run tests that need this parser:

```bash
pytest -m "not osh"
```

If you also want to run these 'parser tests',
there is a Dockerfile to parse shell commands with
the [Oil parser](https://github.com/oilshell/oil):

```bash
# Look in Makefile for details
SHELLWHAT_PARSER='docker' make test
```


## License
[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fdatacamp%2Fshellwhat.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fdatacamp%2Fshellwhat?ref=badge_large)
sixty 0.1
Python wrapper for SIXTE
Requires Python: >=3.6

# sixty
A simple python wrapper for [SIXTE](https://www.sternwarte.uni-erlangen.de/research/sixte/index.php), a software package for X-ray telescope observation simulations.

This module assumes that a working installation of SIXTE and SIMPUT is available in your system. See the installation instructions in the [SIXTE website](https://www.sternwarte.uni-erlangen.de/research/sixte/simulation.php). I have only trested this on linux, I don't know if it would work on macOS.


Example
-------
```
import sixty

sixty.run("sixteversion")
```

Any command available for SIXTE/SIMPUT can be called by the `run` method. For example, to run the first example presented in the SIXTE website, you can do (assuming you already have the required files):
```
sixty.run(
  "simputfile",
  RA=40.2,
  Dec=12.8,
  XSPECFile="example_spectrum.xcm",
  LCFile=example_lightcurve.dat,
  MJDREF=50800.0,
  Emin=0.5,
  Emax=10.0,
  srcFlux=2.3e-12,
  Simput="example_source.simput",
)
```
tcs-sqlWhat 3.8.1
Submission correctness tests for SQL

# sqlwhat

[![Build Status](https://travis-ci.org/datacamp/sqlwhat.svg?branch=master)](https://travis-ci.org/datacamp/sqlwhat)
[![codecov](https://codecov.io/gh/datacamp/sqlwhat/branch/master/graph/badge.svg)](https://codecov.io/gh/datacamp/sqlwhat)
[![PyPI version](https://badge.fury.io/py/sqlwhat.svg)](https://badge.fury.io/py/sqlwhat)

`sqlwhat` enables you to write Submission Correctness Tests (SCTs) for interactive SQL exercises on DataCamp.

- If you are new to teaching on DataCamp, check out https://authoring.datacamp.com.
- If you want to learn what SCTs are and how they work, visit [this article](https://authoring.datacamp.com/courses/exercises/technical-details/sct.html) specifically.
- For more information about writing SCTs for SQL exercises, consult https://sqlwhat.readthedocs.io.

## Installing

```
pip install sqlwhat     # install from pypi
make install            # install from source
```

## Reference

* API Docs: https://sqlwhat.readthedocs.io
* AST viewer: https://ast-viewer.datacamp.com
* Extensions: https://github.com/datacamp/sqlwhat-ext

## Raising issues with how SQL is parsed

Please raise an issue on the respsective parser repo:

* [antlr-tsql](https://github.com/datacamp/antlr-tsql)
* [antlr-psql](https://github.com/datacamp/antlr-plsql)

## Basic Use

```python
from sqlwhat.State import State    # State holds info needed for tests
from sqlwhat.Reporter import Reporter
from sqlwhat.checks import *       # imports all SCTs
from sqlalchemy import create_engine

code = "SELECT * FROM artists WHERE id < 100"

state = State(
    student_code = code,
    solution_code = code,
    pre_exercise_code = "",
    student_conn = create_engine('sqlite:///'),
    solution_conn = create_engine('sqlite:///'),
    student_result = {'id': [1,2,3], 'name': ['greg', 'jon', 'martha']},
    solution_result = {'id': [1,2,3], 'name': ['toby', 'keith', 'deb']},
    reporter = Reporter()
    )

# test below passes, since code is equal for student and solution
has_equal_ast(state)

# test below raises a TestFail error, since 'name' col of results
# doesn't match between student and solution results
check_result(state)
# shows error data
state.reporter.build_payload()

# can also be done using a chain
from sqlwhat.sct_syntax import Ex
Ex(state).check_result()
```

## Running unit tests

```bash
pytest -m "not backend"
```

If you also want to run the backend tests, you need to set a `GITHUB_TOKEN` environment variable with access to the (private) `sqlbackend` repository.
After this, you can:

```bash
make install
pytest
```

### Rules of testing

1. Running queries is the backend's job
2. If a test doesn't run queries, it doesn't need the backend
3. Very few tests should run queries

## Building Docs

Install sqlwhat and run ..

```
cd docs
make html
```
url-crawler 1.0.0
A Python library to crawl the details of a URL.
Requires Python: >=3.9.7

# Overview
-----------------------------------------------------------------------------

url_crawler is a Python library to crawl the details of a URL. 

## Usage

    from url_crawler import url_crawler
    '''
      url -> string URL to crawl for information.
    '''
    package_details = url_crawler(url)
    
    print(package_details.url)
    print(package_details.domain)
    print(package_details.check_https)
    print(package_details.dot_count)
    print(package_details.digit_count)
    print(package_details.url_length)
    
**Utilities**

| Name           | Output | Description  |
| ------------- | -----| -----|
| url | str | Returns the string url. |
| domain | str | Returns the domain of the url. |
| registrar | str | Returns the registrar for the given URL. |
| registered_country | str | Returns the registered domain country of the given URL. |
| whois | dict | Returns the whois information of the given URL. |
| registration_date | int | Returns the number of days since registration of the given URL. |
| expiry_date | int | Returns the number of days to expiration of the given URL. |
| intended_lifespan | int | Returns the number of days of intended lifespan of the given URL. |
| dot_count | int | Returns the dot(.) count in the given URL. |
| digit_count | int | Returns the digit count in the given URL. |
| url_length | int | Returns the length of the given URL. |
| fragments_count | int | Returns the fragment counts in the given URL. |
| entropy | int | Returns the entropy of the given URL. |
| check_http | bool | Checks for http headers in the given URL. |
| check_http | bool | Checks for https headers in the given URL. |
| url_response | bool | Checks for the URL response. |
| check_encoding | bool | Checks for encoding in in the given URL. |
| check_client | bool | Checks for client keyword in the given URL. |
| check_admin | bool | Checks for admin keyword in the given URL. |
| check_server | bool | Checks for server keyword in the given URL. |
| check_login | bool | Checks for login keyword in the given URL. |
| check_ports | bool | Checks for any ports in the given URL. |

## Requirements

The `requirements.txt` file has details of all Python libraries for this package, and can be installed using 
```
pip install -r requirements.txt
```

## Organization

    ├── src
    │   ├── url_crawler
              ├── init             <- init
              ├── url_crawler      <- package source code for URL crawler
    ├── setup.py             <- setup file 
    ├── LICENSE              <- LICENSE
    ├── README.md            <- README
    ├── CONTRIBUTING.md      <- contribution
    ├── test.py              <- test cases for unit testing
    ├── requirements.txt     <- requirements file for reproducing the code package

## License

MIT

## Contributions

For steps on code contribution, please see [CONTRIBUTING](./CONTRIBUTING.md).
robotframework-rosgazebolibrary 0.0.5
Keyword library for the Robot Framework for accessing ROS based systems and the Gazebo simulator.
Requires Python: >=3.6

# Robot Framework ROS Gazebo Library

[![PyPI](https://img.shields.io/pypi/v/robotframework-rosgazebolibrary)](https://pypi.org/project/robotframework-rosgazebolibrary/)
[![Apache 2.0 License](https://img.shields.io/github/license/hielsnoppe/robotframework-rosgazebolibrary)](https://apache.org/licenses/LICENSE-2.0)
[![CodeFactor](https://www.codefactor.io/repository/github/hielsnoppe/robotframework-rosgazebolibrary/badge)](https://www.codefactor.io/repository/github/hielsnoppe/robotframework-rosgazebolibrary)

Keyword library for the [Robot Framework](https://robotframework.org/) for accessing [ROS](https://www.ros.org/) based systems and the [Gazebo simulator](http://gazebosim.org/).

Copyright 2020-2022 [Fraunhofer FOKUS](https://www.fokus.fraunhofer.de/)

The initial version of this software was developed at the [Fraunhofer Institute for Open Communication Systems (FOKUS)](https://www.fokus.fraunhofer.de/).
Initial development was funded by the ITEA3 project [eXcellence in Variant Testing (XIVT)](https://itea4.org/project/xivt.html).

## Installation

You can install this library from the [Python Package Index](https://pypi.org/project/robotframework-rosgazebolibrary/) as follows:

    pip install robotframework-rosgazebolibrary

See also the [installation instructions](https://github.com/robotframework/robotframework/blob/master/INSTALL.rst) for Robot Framework.

## Documentation

In principle, the following command should create HTML documentation:

    python -m robot.libdoc src/RosGazeboLibrary docs/index.html

Unfortunately, this does not work at the moment.
Feel free to create a pull request if you know how to fix this.

## License

The Robot Framework Ros Gazebo Library is open source software provided under the [Apache License 2.0](https://apache.org/licenses/LICENSE-2.0)