semvec/pypi-packages huggingface dataset:
pop-cli 7.0.1
A POP cli interface
Requires Python: >=3.10

=======
Pop-cli
=======

A cli interface for pop that exposes a persistent hub on the command line.

Getting Started
===============

First off, install ``cPop`` from pypi:

.. code-block:: bash

    pip3 install pop-cli



You can now initialize pop from the cli:

.. code-block:: bash

    python -m hub my_sub.init.cli

or:

.. code-block:: bash

    hub my_sub.init.cli

Specify a namespace that should host the authoritative CLI by calling using --cli as the first argument:

.. code-block:: bash

    hub --cli=my_app my_sub.init.cli

If you don't specify a --cli, unknown args will be forwarded as parameters to the reference you give:


.. code-block:: bash

    hub pop.test.func arg1 arg2 --kwarg1=asdf --kwarg2 asdf


You can access anything that is on the hub, this is very useful for debugging.

Try this to see the subs that made it onto the hub:

.. code-block:: bash

    hub _subs

You can do this to see everything that made it into hub.OPT:

.. code-block:: bash

    hub OPT

Start an interactive python shell that includes a hub and allows async code to be run:

.. code-block:: bash

    hub -i
    #>>> await hub.lib.asyncio.sleep(0)


Release
=======
The following steps are how to release a project with hatch

.. code-block:: bash

    pip install .\[build\]
    hatch build
    export HATCH_INDEX_USER="__token__"
    export HATCH_INDEX_AUTH="pypi-api-token"
    hatch publish


Documentation
=============

Check out the docs for more information:

https://pop.readthedocs.io

There is a much more in depth tutorial here, followed by documents on how to
think in Plugin Oriented Programming. Take your time to read it, it is not long
and can change how you look at writing software!
mcfinance 0.1.8
Money control financial data extractor-Requires python 3.7+
Keywords: python, financial, extractor, data


# mcfinance

### Developed by 05kashyap and ragha1992
### PyPI stats:
[![Downloads](https://static.pepy.tech/badge/mcfinance)](https://pepy.tech/project/mcfinance)
## Description:

Extract financial data from the money control website using the company name, BSE or NSE number.
Export any selected data into either pandas dataframe or excel sheet with ease!
### .

*Disclaimer*: We are in no way affiliated with moneycontrol.com
 
## Usage:
```python
pip install mcfinance
```
### Initialise company details:
#### Create an Extractor instance with company name/ BSE/ NSE ID (required) and/or number of years(default), required documents(default), and filepath to write documents(default current directory).

```python
from mcfinance import Extractor
Company = Extractor(user_input= "Company_name")
#years and docs are default
Company = Extractor(user_input= "Company_name",years = 10, docs = ["balance sheet", "profit loss"], filepath = "/files")
```
any of the inputs can be changed later on as per user convenience
```python
Company.set_inputs(years = 6)
```
### Export company details as excel file (default)
#### The get_info() function can be used to extract and store company data in an excel file. The file will be stored in the current filepath or the user defined filepath as per object initialisation 

```python
Company.get_info()
```
or
```python
Company.get_info(option = 1)
```

### Export company details into pandas data frame

```python
DataFrame1, DataFrame2, DataFrame3 = Company.get_info(option = 0)
```
### Plot certain attribute over selected years using matplotlib
#### The plotter() function can be used to show the companies attribute from a certain document over the selected period of time using a line graph from the matplotlib library. The function accepts a single required arguement for the attribute selection. 

```python
company.plotter("certain file attribute of the document")
```
#### Usage example: 

```python
cmp = Extractor("TCS", years = 10, docs = ["ratios"])
cmp.plotter("EV/EBITDA (X)")
```
output:

![image](https://github.com/05kashyap/moneycontrol_financial-extractor/assets/120780494/f5be744e-e065-4b03-b6df-2ca7e765c4b2)

### We can also plot the data of multiple companies on the same graph for comparison purposes
```python
company1 = Extractor("TCS", years = 10, docs = ["ratios"])
company2 = Extractor("Infosys", years = 10, docs = ["ratios"])
Extractor.cmp_plot(comp = [company1, company2], attributes = "EV/EBITDA (X)")
```
output:

![image](https://github.com/05kashyap/mcfinance/assets/120780494/294f8313-2876-4751-9485-18517dccb0d3)
smartschoolapi-tkbstudios 1.2.0
A python package to interact with SmartSchool, a Belgian School Management System
Requires Python: >=3.12

# SmartSchool Client
I made this library to communicate with smartschool for some reason.  
I was able to bind it with a voice assistant to tell me when I get a new message. (Home Assistant for reference)

# How to use
Install using ``pip install smartschoolapi_tkbstudios -U``

# Legal
This library complies with the [SmartSchool User Agreement](https://www.smartschool.be/gebruikersovereenkomst/).  
I am **NOT** responsible for anything that a user does with this library.  
Please comply with the SS User Agreement! Not doing so will result in legal consequences.  
Again, please do **NOT** break those rules, it's for your best.


# License
This project is licensed under the [MIT license](https://github.com/tkbstudios/SmartSchoolPyClient/blob/master/LICENSE)
MicsStructure 0.1.2
Mics Structure - module for website

-- MicsStructure --


-- A module for the website --


-- Functionality --


A function that will allow you to make files/folders for your project with 1 line of code

    startCreate() 

To create the code, use the code below or the function
 
    createCode(codeInput='code')


Everything that a project can create

    folder_name.mkdir
    name_python_file.СЂСѓ the name of the
    name_json_file.json
synapse-auto-accept-invite 1.2.0
"Synapse module to automatically accept invites"
Requires Python: >=3.7

# Auto-accept invites

Synapse module to automatically accept invites.

Compatible with Synapse v1.84.0 and later.

## Installation

From the virtual environment that you use for Synapse, install this module with:
```shell
pip install synapse-auto-accept-invite
```
(If you run into issues, you may need to upgrade `pip` first, e.g. by running
`pip install --upgrade pip`)

Then alter your homeserver configuration, adding to your `modules` configuration:
```yaml
modules:
  - module: synapse_auto_accept_invite.InviteAutoAccepter
    config:
      # Optional: if set to true, then only invites for direct messages (1:1 rooms)
      # will be auto accepted.
      # Defaults to false.
      accept_invites_only_for_direct_messages: false

      # Optional: if set to true, then only invites from local users will be auto 
      # accepted.
      # Defaults to false.
      accept_invites_only_from_local_users: false

      # (For workerised Synapse deployments)
      #
      # This module should only be active on a single worker process at once,
      # otherwise invites may be accepted by multiple workers simultaneously.
      #
      # By default, this module is only enabled on the main process, and is disabled
      # on workers. To choose a worker to run this module on (to reduce load on the
      # main process), specify that worker's configured 'worker_name' below.
      #
      # Any worker may be specified. If this worker does not have the ability to
      # write to Synapse's events stream, it will end up calling out to one that
      # does.
      #
      #worker_to_run_on: workername1
```


### A note about logging

Your Synapse logging configuration should have the following option set in it:

```yaml
disable_existing_loggers: False
```

Without it, logging from this module (and potentially others) may not appear in your logs.


## Development

In a virtual environment with pip ≥ 21.1, run
```shell
pip install -e .[dev]
```

To run the unit tests, you can either use:
```shell
tox -e py
```
or
```shell
trial tests
```

To run the linters and `mypy` type checker, use `./scripts-dev/lint.sh`.


## Releasing

 1. Set a shell variable to the version you are releasing (this just makes
    subsequent steps easier):
    ```shell
    version=X.Y.Z
    ```

 2. Update `setup.cfg` so that the `version` is correct.

 3. Stage the changed files and commit.
    ```shell
    git add -u
    git commit -m v$version -n
    ```

 4. Push your changes.
    ```shell
    git push
    ```

 5. When ready, create a signed tag for the release:
    ```shell
    git tag -s v$version
    ```
    Base the tag message on the changelog.

 6. Push the tag.
    ```shell
    git push origin tag v$version
    ```

 7. Create a source distribution and upload it to PyPI:
    ```shell
    python -m build
    twine upload dist/synapse_auto_accept_invite-$version*
    ```
lib-version-team11 0.0.1
A version-aware library that can be asked for the version of the library.
Requires Python: <4.0,>=3.11

# lib-version
A version-aware library that can can be asked for the version of the library.


## Methods
- `get_version()`: Returns the version of the library.
- `print_version()`: Prints the version of the library.

## Usage
```python
from lib_version_team11 import VersionUtil

# Get the version of the library
version = VersionUtil.get_version()
```

## Installation
```bash
pip install lib_version_team11
```

## Releasing
Create a new git tag and push it to the repository. The CI/CD pipeline will automatically publish the new version to PyPi.

```bash
git tag v0.1.0
git push origin v0.1.0
```

Note: The version number should follow the semantic versioning format, i.e., `vX.Y.Z` where `X`, `Y`, and `Z` are non-negative integers. Note that the version number should be prefixed with a `v`.
tennis-big3 0.1.2
Library which shows stats about the Big Three era in Tennis (2000's, 2010's)

# Big Three Library

A library with the stats of Grand Slams earned by the Big Three:

    - Rafa Nadal (Spain) Grand Slams: 22
    - Roger Federer (Swizterland) Grand Slams: 20
    - Novak Djokovic (Serbia) Grand Slams: 24


## Installation

Install the package using `pip`:

```bash
pip3 install tennis-big3
```

## List the Big-3

```python3
from tennis_big3 import list_players

list_players()
```

You can do it by this other way:

```python3
from tennis_big3.players import big_three

for player in big_three:
    print(player)
```

## Search player by the name

If you want to search the stat of a single player:

```python3
from tennis_big3 import search_player

search_player("Roger Federer")
```

## Show total of GS

```python3
from tennis_big3 import total_gs

total_gs()
```