semvec/pypi-packages huggingface dataset:
cbcc 0.2.0
Clarity Backend Code Challenge
Requires Python: >=3.8,<4.0

BACKEND CODE CHALLENGE
========

Introduction
--------
#
First of all I would like to say I used to work more with data related environments like collab notebooks managing pandas dataframes but this approach force me to learn a more object-oriented develop, which I found pretty useful and enjoyable.

The "tool" is developed using poetry, which is a tool to handle dependency installation as well as building and packaging Python packages.

> (We only have *pyproject.toml* instead of setup.py, requirements.txt, ...)

Outline
--------
#
All the functional code is inside the *parser.py* script.

We can divide it in three main parts:
- The Connection class:
This class establish a first structure to deal with the logs as an object

- Auxiliary functions
  - **preriodFilter**: Filter to check dates inside interval
  - **hostsInPeriod**: gets hosts connected in the interval
  - **parseLogs**: open the logfile and create the connectionsRc
  
- Main functions
  - **connectionsRealized**: Structures the connections in three dictionaries:
    - connections realized from host
    - connections received from host
    - total connections from host
  - **follow**: lets keep listening to the possible new logs in the logfile, also filters them in a period and for a host
  - **parseInfinitively**: divides the lines inside the logfile and runs follow

How it Works:
--------
#
### First exercise

1. Gets *connections-received* dictionary following this structure:

        { destiny-host, Connection, Connection, ... }

2. Filters getting only the connections received in a period of time
3. Gets the connections received from the host indicated
#
### Second exercise
1. Gets connections dictionaries for: 
    - *connections-received* (like the first exercise)
    - *connections-realized* from a host and counter of total
    - *total connections for each host*

> With timestamps and dates, we make sure this exercise runs periodically each hour (unless we force stop)

3. After this, what we have is basically the follow function:
    - Gets the actual time
    - Runs a loop each 0,1 seconds
        - Meanwhile gets new lines written inside the logfile
    - When the amount of time (3600 seconds = 1 hour) is reached, we print the connections (commented in point [1](#second-exercise)) done in the last hour from the host indicated

Installation & Run
------------
#
### Install
 

    pip install poetry
    ClarityBackenCodeChallenge\poetry update
    poetry update

### Run

    poetry run python \parser\parser.py \parser\input.txt
qtile-window-trashbin 0.0.2
A thrashbin for qtile windows.

# qtile-window-trashbin
Qtile Extension to reopen closed windows. Never think "Oh shit" again when you close a window.

## Installation
You can install the package using pip
```bash
pip install qtile-window-trashbin
```

## Usage
This module adds a "Thrashbin" class. Use it in your keybindings instead of kill. The pane will be killed after a given time.

U could put the following in your ~/.config/qtile/config.py
```python
from trashbin import Trashbin

trash_group = ScratchPad("killPane") #We use an invisible Group: A ScratchPad.
groups.extend([trash_group]) # Let's append it to to groups.

trash = Trashbin(trash_group.name, delay=5) # Initialize the Trashbin. Use the newly created Group to store the windows. Kill a Window put to the trashbin afert 5 seconds.

keys.extend([
    Key([mod], "q", lazy.function(trash.append_currend_window)), # move to trash
    Key([mod, "shift"], "q", lazy.window.kill()), # real kill. Sometimes you want to kill insteadly.
    Key([mod, "shift"], "e", lazy.function(trash.pop_to_current_group)) # Restore the last window put to the trashbin.
    ])

```
Afterwards you can hit `Super + q` and the current window be moved to the trash.
Hit `Super + Shift + e` to restore the last window, put to the trashbin.
Sometimes moving a window to the trash is not what you want.
For example when quiting an video player you may want to stop the playing immediately.
Hit `Super + Shift + q` to quit immediatley. Caution: This is not undoable.
pyrat-sdrabing 0.2.1
R-like vectors and functions in Python.

# PyRat

R-like vectors and functions in Python.

## Warning

This is not Pandas, or scikit-learn, or numpy. This is not R, either. Do not
use this for industry purposes. Do not use this unless you want your project to
break.

Simply have fun with it, or use this for educational purposes.

## Installation

Clone this repository to your local machine with git, then install with Python.

```bash
git clone https://github.com/shanedrabing/pyrat.git
cd pyrat
python setup.py install
```

## Getting Started

Import the libraries with Python.

```python
import pyrat.base
import pyrat.stats
import pyrat.utils
import pyrat.closure
```

The closure library is the only not inspired by R. All other libraries contain
familiar functions. If you want to locate a function within R, look into the
`find` function, determine the namespace, and see if PyRat contains the
function!

## Motivating Examples

So, why use PyRat? If you're a fan of R (like myself), you may have learned
that the capabilities of vectors and functions that operate on them are
immensely powerful.

### Linear Modeling

Let's try modeling a line of best fit between horsepower and miles per gallon
from the `mtcars` dataset:

```python
import matplotlib.pyplot as plt

from pyrat.base import log10, seq
from pyrat.stats import lm, predict
from pyrat.utils import read_csv, struct

df = read_csv("data/mtcars.csv")

x = df["hp"]
y = df["mpg"]

m = lm(log10(x), log10(y))

x_new = seq(min(x), max(x), length_out=101)
y_new = 10 ** predict(m, log10(x_new))

plt.scatter(x, y, color="black")
plt.plot(x_new, y_new, color="red")
plt.xlabel("Horsepower")
plt.ylabel("Miles per Gallon")
plt.tight_layout()
plt.savefig("data/fit.png")
plt.clf()
```

A plot of the fitted linear model:

![data/fit.png](data/fit.png)

### Functional Programming

PyRat has its own version of "piping", whereby the items of a `vector` (or the
`vector` itself) can be continuously operated on. All intermediates are
immutable, as the `vector` is just a `tuple` on steroids.

```python
from pyrat.base import c, paste

taxa = c("Canis lupus", "Felis catus", "Ursidae", "Anura (order)")

print(
    taxa
    .apply("https://en.wikipedia.org/w/index.php?search={}".format)
    .thread(requests.get)
    .apply(getattr, "content")
    .apply(bs4.BeautifulSoup, "lxml")
    .apply(bs4.BeautifulSoup.select_one, "h1")
    .apply(getattr, "text")
    .transform(paste, "(" + taxa + ")", collapse="\n")
)
```

Here's the output:

```txt
Wolf (Canis lupus)
Cat (Felis catus)
Bear (Ursidae)
Frog (Anura (order))
```
curse-app-api 1.0.1
Cuseforge App API
Requires Python: >=3.6
Keywords: python,minecraft,curseforge

Project description might be outdated on [PyPI], latest version available on [Github].


# **Curseforge App API**
The package provides classes to interact with Curseforge app API.

**Note: I wrote neither API nor documentation** (btw documentation with methods and results took from [there]).



# Installation/Upgrade

1) Requires at least python 3.6

2) Install/Upgrade with $ pip install --user --upgrade curse-app-api

# Requirements
```
requests>=2.25.1
selenium>=3.141.0
selenium-requests>=1.3
webdriver-manager>=3.4.2
msedge-selenium-tools>=3.141.3
```


## Usage:
```python
# getting API class
from curse_app_api import CurseAPI, WDCurseAPI

# creating API class
api = CurseAPI()

# example method 
print(api.get_category_timestamp())

# using API with webdriver (this part works slowly because it downloads webdrivers and tries to invoke them)
wdapi = WDCurseAPI()

# it will print the same result as previous print
print(wdapi.get_category_timestamp())

# also if something goes wrong, you can get last query link
print(api.last_query_link)

# and its response
print(api.last_response)
```


# Current supported WebDrivers
For current supported web drivers you don't have to download them and install manually. 
To use Safari web driver, you need to configure it first: run once 
`safaridriver --enable` in terminal.
```textmate
ChromiumDriver
MSEdgeDriver
GeckoDriver (Firefox)
OperaChromiumDriver
Safari web driver
```

# Contributing
If you want to contribute: 

1) If you find bugs related to this project, open an issue in 
Github issues tracker.


2) If you want add a new feature, fork this repo, make changes locally and open a pull request. I'll check changes 
   myself and merge your code into main branch.

**Note:** This API implements curseforge **APP** API != Curseforge. It means that not all projects on Curseforge can be captured by API, only those, 
which seen by Curseforge Desktop. 
So don't report bugs related to this unless project can be seen by Curseforge desktop. If you report this bug, please, provide a screenshot
that your project wasn't captured by API but can be seen in Curseforge Desktop.

# TODO   
Caching webdriver for subsequent usage.

[there]: https://curseforgeapi.docs.apiary.io/
[Github]: https://github.com/CyberSteve777/CurseAppAPI/
[Pypi]: https://pypi.org/project/curse-app-api/
pyrat-drabing 0.2.1
R-like vectors and functions in Python.

# PyRat

R-like vectors and functions in Python.

## Warning

This is not Pandas, or scikit-learn, or numpy. This is not R, either. Do not
use this for industry purposes. Do not use this unless you want your project to
break.

Simply have fun with it, or use this for educational purposes.

## Installation

Clone this repository to your local machine with git, then install with Python.

```bash
git clone https://github.com/shanedrabing/pyrat.git
cd pyrat
python setup.py install
```

## Getting Started

Import the libraries with Python.

```python
import pyrat.base
import pyrat.stats
import pyrat.utils
import pyrat.closure
```

The closure library is the only not inspired by R. All other libraries contain
familiar functions. If you want to locate a function within R, look into the
`find` function, determine the namespace, and see if PyRat contains the
function!

## Motivating Examples

So, why use PyRat? If you're a fan of R (like myself), you may have learned
that the capabilities of vectors and functions that operate on them are
immensely powerful.

### Linear Modeling

Let's try modeling a line of best fit between horsepower and miles per gallon
from the `mtcars` dataset:

```python
import matplotlib.pyplot as plt

from pyrat.base import log10, seq
from pyrat.stats import lm, predict
from pyrat.utils import read_csv, struct

df = read_csv("data/mtcars.csv")

x = df["hp"]
y = df["mpg"]

m = lm(log10(x), log10(y))

x_new = seq(min(x), max(x), length_out=101)
y_new = 10 ** predict(m, log10(x_new))

plt.scatter(x, y, color="black")
plt.plot(x_new, y_new, color="red")
plt.xlabel("Horsepower")
plt.ylabel("Miles per Gallon")
plt.tight_layout()
plt.savefig("data/fit.png")
plt.clf()
```

A plot of the fitted linear model:

![data/fit.png](data/fit.png)

### Functional Programming

PyRat has its own version of "piping", whereby the items of a `vector` (or the
`vector` itself) can be continuously operated on. All intermediates are
immutable, as the `vector` is just a `tuple` on steroids.

```python
from pyrat.base import c, paste

taxa = c("Canis lupus", "Felis catus", "Ursidae", "Anura (order)")

print(
    taxa
    .apply("https://en.wikipedia.org/w/index.php?search={}".format)
    .thread(requests.get)
    .apply(getattr, "content")
    .apply(bs4.BeautifulSoup, "lxml")
    .apply(bs4.BeautifulSoup.select_one, "h1")
    .apply(getattr, "text")
    .transform(paste, "(" + taxa + ")", collapse="\n")
)
```

Here's the output:

```txt
Wolf (Canis lupus)
Cat (Felis catus)
Bear (Ursidae)
Frog (Anura (order))
```
snipyr 0.2.1
R-like vectors and functions in Python.

# PyRat

R-like vectors and functions in Python.

## Warning

This is not Pandas, or scikit-learn, or numpy. This is not R, either. Do not
use this for industry purposes. Do not use this unless you want your project to
break.

Simply have fun with it, or use this for educational purposes.

## Installation

Clone this repository to your local machine with git, then install with Python.

```bash
git clone https://github.com/shanedrabing/pyrat.git
cd pyrat
python setup.py install
```

## Getting Started

Import the libraries with Python.

```python
import pyrat.base
import pyrat.stats
import pyrat.utils
import pyrat.closure
```

The closure library is the only not inspired by R. All other libraries contain
familiar functions. If you want to locate a function within R, look into the
`find` function, determine the namespace, and see if PyRat contains the
function!

## Motivating Examples

So, why use PyRat? If you're a fan of R (like myself), you may have learned
that the capabilities of vectors and functions that operate on them are
immensely powerful.

### Linear Modeling

Let's try modeling a line of best fit between horsepower and miles per gallon
from the `mtcars` dataset:

```python
import matplotlib.pyplot as plt

from pyrat.base import log10, seq
from pyrat.stats import lm, predict
from pyrat.utils import read_csv, struct

df = read_csv("data/mtcars.csv")

x = df["hp"]
y = df["mpg"]

m = lm(log10(x), log10(y))

x_new = seq(min(x), max(x), length_out=101)
y_new = 10 ** predict(m, log10(x_new))

plt.scatter(x, y, color="black")
plt.plot(x_new, y_new, color="red")
plt.xlabel("Horsepower")
plt.ylabel("Miles per Gallon")
plt.tight_layout()
plt.savefig("data/fit.png")
plt.clf()
```

A plot of the fitted linear model:

![data/fit.png](data/fit.png)

### Functional Programming

PyRat has its own version of "piping", whereby the items of a `vector` (or the
`vector` itself) can be continuously operated on. All intermediates are
immutable, as the `vector` is just a `tuple` on steroids.

```python
from pyrat.base import c, paste

taxa = c("Canis lupus", "Felis catus", "Ursidae", "Anura (order)")

print(
    taxa
    .apply("https://en.wikipedia.org/w/index.php?search={}".format)
    .thread(requests.get)
    .apply(getattr, "content")
    .apply(bs4.BeautifulSoup, "lxml")
    .apply(bs4.BeautifulSoup.select_one, "h1")
    .apply(getattr, "text")
    .transform(paste, "(" + taxa + ")", collapse="\n")
)
```

Here's the output:

```txt
Wolf (Canis lupus)
Cat (Felis catus)
Bear (Ursidae)
Frog (Anura (order))
```
pybitbackup 0.0.5
A Python tool to download all your BitBucket projects
Requires Python: >=3.9

[<img src="https://img.shields.io/pypi/v/pybitbackup">](https://pypi.org/project/pybitbackup/)
<img src="https://img.shields.io/badge/python-3.9-blue">
<img src="https://img.shields.io/badge/license-MIT-green">

# Bitbackup

## Description
This Python script will download all of your Git repositories from a Bitbucket workspace.
If a repository does not exist locally, the repo will be downloaded to the target directory. If a
repository already exists locally, `git remote update` will be executed.


## Installation
```bash
pip install pybitbackup 
```

## Usage
Download all projects from a BitBucket workspace into the current folder:
```bash
pybitbackup <workspace> --user <Username> --key <App Key>
```
_App Key_ and _Username_ a required to access the Bitbucket API. You can easily generate a new App Key
at your personal [settings page](https://bitbucket.org/account/settings/app-passwords/) in Bitbucket.
_Workspace_ could be your own _username_ to download your personal repositories or one of the team workspaces.
To download only repositories of a certain project, you can specify the _project name_.