Saravanan666/pypi-org huggingface dataset:
Package: setopati-reader
# Setopati Python Feed ReaderThe Setopati Feed Reader is a basic [web feed](https://en.wikipedia.org/wiki/Web_feed) reader that can download the latest new from the Setopati news [Setopati feed](https://setopati.net/feed).## InstallationYou can install the Setopati Feed Reader from [PyPI](https://pypi.org/project/setopati-reader/):pip install setopati-readerThe reader is supported on Python 2.7, as well as Python 3.4 and above.## How to useThe Setopati Feed Reader is a command line application, namedsetopati. To see a list of news simply call the program:$ setopati
The latest tutorials from Setopati – Nepal’s Digital Newspaper (https://setopati.net)
0 Trump, Xi to talk trade
1 Trump says he could meet Kim at DMZ
2 Govt will have to spend almost Rs 1 billion for IIFA Awards
3 SC asks govt reasons for doling out Rs 60m to federal lawmakers
4 This govt will serve for five years: Barsha Man Pun
5 Don’t meddle in the election: Trump jokes with Putin
6 Man involved in attacks on women with pointed objects arrested
7 Rivals target Biden as Democrats’ rifts emerge on race, age
8 Boeing aims to finish software fix to 737 Max in September
9 Oli woos ministers with Maoist background assuring there’ll be no cabinet reshuffleYou can also call the Real Setopait Feed Reader in your own Python code, by importing from thereaderpackage:>>> from reader import feed
>>> feed.get_titles()
['Trump, Xi to talk trade', ...]
Package: setoptconf
setoptconfis a Python library that can be used to retrieve program settings
from a variety of common sources:Command LineEnvironment VariablesINI FilesJSON FilesYAML FilesPython Objects/ModulesThe goal of this project is to define your desired settings in a simple and
consistent way, and then point setoptconf at as many of the sources as you’d
like to use, and let it comb them all, looking for your settings.This README is admittedly very light on details. Full documentation will come
in time. For now, here’s an example of its use:Import the library:import setoptconf as socInstantiate the manager:manager = soc.ConfigurationManager('myprogram')Define the settings we’d like to collect:manager.add(soc.StringSetting('foo'))
manager.add(soc.IntegerSetting('bar', required=True))
manager.add(soc.BooleanSetting('baz', default=True))Retreive the settings from our desired sources, combining the settings and
overriding with the priority implied by the order of the sources we pass:config = manager.retrieve(
    # This source pulls from the command line using argparse.
    soc.CommandLineSource,

    # This source pulls from environment variables that are prefixed
    # with MYPROGRAM_*
    soc.EnvironmentVariableSource,

    # This source pulls from the named INI files. It stops at the first
    # file it finds.
    soc.ConfigFileSource(('.myprogramrc', '/etc/myprogram.conf')),
)We now have a Configuration object namedconfigthat has three attributes;foo,bar, andbaz.
Package: setoptconf-tmp
IMPORTANT!This is a fork ofsetoptconf.
It is a temporary solution to fixprospectorbeing unable to install due to setoptconf not working with setuptools >= 58 -
seethe issue here.This package is only meant as a temporary solution to fix CI builds using prosector
until setoptconf can be removed from there. Therefore do not expect this fork to be
maintained and it will be purged once prospector is updated.setoptconf-tmpsetoptconfis a Python library that can be used to retrieve program settings
from a variety of common sources:Command LineEnvironment VariablesINI FilesJSON FilesYAML FilesPython Objects/ModulesThe goal of this project is to define your desired settings in a simple and
consistent way, and then point setoptconf at as many of the sources as you’d
like to use, and let it comb them all, looking for your settings.This README is admittedly very light on details. Full documentation will come
in time. For now, here’s an example of its use:Import the library:import setoptconf as socInstantiate the manager:manager = soc.ConfigurationManager('myprogram')Define the settings we’d like to collect:manager.add(soc.StringSetting('foo'))
manager.add(soc.IntegerSetting('bar', required=True))
manager.add(soc.BooleanSetting('baz', default=True))Retreive the settings from our desired sources, combining the settings and
overriding with the priority implied by the order of the sources we pass:config = manager.retrieve(
    # This source pulls from the command line using argparse.
    soc.CommandLineSource,

    # This source pulls from environment variables that are prefixed
    # with MYPROGRAM_*
    soc.EnvironmentVariableSource,

    # This source pulls from the named INI files. It stops at the first
    # file it finds.
    soc.ConfigFileSource(('.myprogramrc', '/etc/myprogram.conf')),
)We now have a Configuration object namedconfigthat has three attributes;foo,bar, andbaz.
Package: setor
SETOR is a Bot TOR to visit the webpages with unique IP’s and random times.InstallSETOR is available directly fromPyPI:$ sudo pip install setorFeaturesSingle URL - Visit to single url.Multiple URL’s - Visit to multiple url’s/links.Logs(Rename the log every midnight)if you need to save as log to/var/logs/setor.Already detected bygoo.glandbit.ly.UsageI think common people know how to use it, especially if you are a Linux User.LicenseMIT
Package: set-package-attribute
set-package-attributeRun modules inside packages as scripts.  Automatically sets the__package__attribute of any script which imports it and calls the initialization functionset_package_attribute.init().  This allows the script to use explicit relative
imports, which fail otherwise.For full documentation, seehttps://abarker.github.io/set-package-attribute.Also available on PyPI for installation with pip.Brief usage summaryTo use the package just import it before any of the non-system files, inside any
module that you might want to run as a script, and call theinitfunction.
These statements should be inside a guard conditional, so that they only run
when the module is executed as a script:if __name__ == "__main__":
    import set_package_attribute
    set_package_attribute.init()The guard conditional is not required if the module isonlyever run as a
script, i.e., if it is never imported by any module.  Theinitfunction must
be calledbeforeany explicit relative imports, and before importing any
modules from within the same package which themselves use such imports.If you are happy with the defaultinitarguments then there is a shortcut
import which automatically callsinitfor you:if __name__ == "__main__":
    import set_package_attribute_magic
Package: setproj
SETPROJHave project setupinstantlyoncli.As programmer and terminal(and terminal tools) lover, I wanted something which will ease the redundant task of setting up project for the languages I use. The following project helps in achieving just that.Let's see how it is done. Here's a project creation demo forjavalanguage:Supported Languages/Tools:Currenlty, following languages(and tool/s) are supported in this project forproject creation:CC++JavaPythonWeb Designing(html,css,js)Java-ServletJavaFXWhat it does:It's an interactive project which puts all the necessary files/folders in place as user tells and fills up some things already which is to be filled everytime,Here's an example of fillup forJava-ServletandJavaFX:And here's the directory hierarchy for all the supported languages:C:C++:Java:Java Servlet:JavaFX:Python:Web Designing:```
Note: This project is still in development stage
```
Package: setpwef
setpwefsetpwef는 set password excel file의 줄임말로 엑셀 파일에 암호를 걸 수 있는 파이썬 패키지입니다. 이 패키지는 Rust 라이브러리를 파이썬에서 사용할 수 있도록 바인딩한 것이며, 사용한 Rust 라이브러리는umya-spreadsheet입니다. 바인딩의 경우PyO3와Maturin을 사용하였습니다.setpwef is an abbreviation for set password excel file, which is a Python package that can set a password for an excel file. This package binds the Rust library for use in Python, and the Rust library used isumya-spreadsheet. For binding,PyO3andMaturinwere used.How to Use패키지 설치하기먼저 패키지를 설치합니다.you have to install kbodata package first.pipinstallsetpwef파일 비밀번호 설정하기엑셀 파일에 비밀번호를 설정합니다.
Set a password for the excel file.importosimportsetpweffilename="test.xlsx"prefix=os.path.join(os.path.dirname(os.path.abspath("test.xlsx")))path=prefix+"/"+filenamepassword="test123"setpwef.encrypt_excelfile(path,path,password)
Package: setr
setr - Search for Extra-Terrestrial Ranges------------------------------------------A grab bag of better ranges for Python projects.Is it good?===========Yup, but it is small.Installation============` pip install setr `TODOs=====1. Allow MultiRange not to need to sort after ever addition.- A function that requires sorting should check a boolean value and sort if nec.2. Create an iter for MultiRange.3. Create BigRange.4. Allow the use of steps.5. Think about implementing a __sum__.6. Add examples in this README.News====setr 0.2.0----------*Release date: 07-Jan-2013*- Alpha release!- Sort of tested, sort of stable, and mostly untrustworthy fast and multi ranges.- Fixes a very bad off by 1 error.setr 0.1--------*Release date: 07-Jan-2013*- Initial pre-alpha release!- Untested, unstable, and untrustworthy fast and multi ranges.- Clobbers over top of your existing well working max() and min()! Import with caution!
Package: sett
SETT - Secure Encryption and Transfer Toolsettenables packaging, encryption, and transfer of data to pre-configured
locations.DocumentationDetailed documentation as well as a quick-start guide can be found in thesett documentation.For the latest, non-stable, version of the docs, seehere.settis also available as adocker container(command line interface
only). For details, seethis README.Documentation quick-linksRequirements and installation.Quick-start guide.Creating and managing GnuPG keys with sett.Using sett to encrypt, transfer and decrypt dataUnit tests coveragePlease note that a number of gui-specific files are excluded from the unit
tests coverage. The detailed list of excluded files can be found inpyproject.toml, under the[tool.coverage.run]section.
Package: settei
Configuration utility for common Python applications and services.
FYI, “settei” (設定) means settings in Japanese. :)Loading a configuration is easySuppose you useFlaskwith Settei.fromflaskimportFlaskfromsetteiimportConfiguration,config_propertyclassWebConfiguration(Configuration):"""Load Configuration::

      [web]
      debug = true

   """#: debug optiondebug=config_property('web.debug',bool,default=False)conf=WebConfiguration.from_path(pathlib.Path('.')/'dev.toml')app=Flask(__name__)if__name__=='__main__':app.run(debug=conf.debug)
Package: settingscascade
IntroOne of the most common ways to let users customize the way an app
works is to use config files. This means that many projects wind up
including an implementation to read in the config values, specify
defaults, control which values get looked up when, and enforce some
sort of schema.settingscascade is designed to handle this scenario. While it can be
used in simple situations, it really shines when you need to pull in
values from a variety of sources, have a rich set of defaults, and
give users flexibility in configuring overrides at various levels.
The model it uses is CSS, mimicking the way that css uses selectors
to cascade settings from various levels of specificity. Your users
specify rule blocks the same as they would in CSS-# Each rule block has a selector, using CSS semantics# this block is for a task element with the class "default"task.default:command:"echohello"on_complete:"echoworld"# You can specify top level settings as well for a final# level of fallbackproject_name:"myproject"Then your app can use the config# Task represents an element (like a div or a in HTML).# you can specify what values are valid for this element typeclassTask(SettingsSchema):_name_=taskcommand:stron_complete:strconfig=SettingsManager(yaml.load("config.yml"),[Task])# In your code, you can pull an element from the settingsmanager# object and find the rules that apply. This is like an element# <task class="default"></task>task_config=config.task(class="default")run_task(command=task_config.command,on_complete=task_config.on_complete,name=config.project_name,)Read the full documentation athttps://settingscascade.readthedocs.io/en/latest/InstallationYou can install settingscascade from pypi-pip install settingscascade
Package: settingsfile
SettingsFileAutoload and autoupdate your configuration with native implementationInstallation$pipinstallsettingsfileQuickstartfromsettingsfileimportSettingssettings=Settings('config.json')# use settings object instance as a dictsettings['language']='fr'# however, you can use it via class attributes too with cautionsettings.language='fr'print(settings['language'])# 'fr'print(settings.language)# 'fr'While using the module via class attributes, there are some names that are reserved and cannot be used as they would conflict. Hence, avoid using commonplace names via attributes such aspath, json, name.Of course, you can use these names in peace via dict-like assignment.
Package: settings-helper
Setup in your packageCreate a default/samplesettings.inifile in the module directory of
your package, with a[default]section and any other[sections]you want (i.e. app environments)[default]
something = 100

[dev]
redis_url = redis://localhost:6379/1
something = 500

[test]
redis_url = redis://localhost:6379/9
things = none, true, false, 1, 2.5, dogsCreate aMANIFEST.infile in your package directory with the
followinginclude settings.iniUpdate thesetup.pyfile of the package to include thesetting.inifile and addsettings-helpertoinstall_requireslistfrom setuptools import setup, find_packages

setup(
    name='package-name',
    version='0.0.1',
    ...
    packages=find_packages(),
    install_requires=[
        'settings-helper',
        ...
    ],
    include_package_data=True,
    package_dir={'': '.'},
    package_data={
        '': ['*.ini'],
    },
    ...
)Note, your package directory tree will be something like the followingpackage-name
├── .gitignore
├── LICENSE.txt
├── MANIFEST.in
├── README.md
├── README.rst
├── package_name/
│   ├── __init__.py
│   └── settings.ini
└── setup.pyUsageUse in__init__.pyof packageimport settings_helper as sh

get_setting = sh.settings_getter(__name__)
something = get_setting('something')
something_else = get_setting('something_else', 'default_val')SetAPP_ENVenvironment variable to be one of your section names
when starting your Python interpreter/server.``APP_ENV`` defaults to
``dev`` if it is not set.Theget_settingfunc will return the value of the requested
variable if it is set in the section specified inAPP_ENV.If the variable is not in the section, it will pull the value from
the[default]sectionIf the varialbe is not in the[default]section either, then
return the optional fallback value passed in thedefaultkeyword
argument toget_setting(which defaults to an empty string)If the requested variable exists in the environment (or its
uppercase equivalent), it will be used instead of getting from
settings.iniThe value is automatically converted to a bool, None, int, or float
if it should beIf the value contains any of (, ; |) then a list of converted values
will be returnedThe first time thatsettings_getterfunc is invoked, it looks for asettings.inifile in~/.config/<package-name>/settings.ini.If it does not find it, it will copy the default settings.ini from
the module’s install directory to that locationIf the settings.ini file does not exist in the module’s install
directory, an exception is raisedAlternate Usageimport settings_helper as sh

settings = sh.get_all_settings(__name__)orimport settings_helper as sh

settings = sh.get_all_settings(__name__).get(sh.APP_ENV, {})Theget_all_settingsfunc returns a dict containing all sections
other than ‘default’.If a setting is defined in ‘default’, but not in a particular
section, the setting in ‘default’ will appear under the sectionIf a setting (or upper-case equivalent) is defined as an environment
variable, that value will be used for all sections that use itTipIn your<package-name>/tests/__init__.pyfile, add the following so
thetestsection of settings is automatically usedimport os

os.environ['APP_ENV'] = 'test'
Package: settings-jc
settings_jcApplication settings package, where defaults are located
in a text file.  The location of text file is root of project or
available from environment variable SETTINGS_JC.Installationpip install settings_jcUpdatepip install -U settings_jcFeaturesDocumentationThe default default settings are in the form:setting_name=valueFor example, if you wish to save the default value for X then your default settings file would contain
the following:X=123Comments are lines starting with #, so an example file may be:# 
# settings.txt
#
# default settings for my application
#
X=123The actual settings are stored in the following folder depending on OS.  The settings are stored in:Windows: %appdata%\appname\settingsUnix/Linux: $HOME/appname/settingsThe settings file is encrypted with a key derived from the computer's system id.This system id should be specific to the execution system.  Please note, it is
very unlikely you could copy the settings file from one system and use
on another system.  Since the system id is unique to the system, the encryption key
will be different for each system.ToDoBugs/RequestsLicenseCopyright Jim Carter, 2020.
Distributed under the terms of the MIT License, settings_jc is free and open source software.
Package: settingsjson
settingsjson.pysimple setting json getterhow to usepipinstallsettingsjsonwrite settings to.settings.json{"DB_PATH":"postgresql://user:secret@host:port/dbname"}read settings from your appsfromsqlalchemyimportcreate_engineimportsettingsjsonsettings=settingsjson.get()db=create_engine(settings["DB_PATH"])echo ".settings.json" >> .gitignore
Package: settings-manager
Settings ManagerSettings Manager is designed to handle settings in python projects.It makes the assumption you are working with environments and building applications.The API consists of 2 functionsload()to load the application settings andsettings()to get access to a dict of the application settings.UsageYou can put environment variables in your yaml config files and they will be loaded from the environment when the file is loaded. Calls to get environment variables likeos.getenv()also work in python config files. Only json config files cannot contain environment variables.You can also havebasefiles i.e.base.pyorbase.ymlorbase.jsonand these will get loaded first. Then the current environment file, for isntancetest.pywill be loaded and override any variables which have the same name inbase.py.Deep Merging: currently the library does not do deep merges i.e. if you have nested hashes in your config files, only top level keys will be merged, not at a fine-grained deep level.Here are some examples.app:secret_key:${SECRET_KEY}google_client_id:${GOOGLE_CLIENT_ID}SECRET_KEY=os.getenv('SECRET_KEY')GOOGLE_CLIENT_ID=os.getenv('GOOGLE_CLIENT_ID')JSON Config FilesImagine you are working on a project with the following structure:myapp/
  app.py
config/
  settings/
    test.json
    dev.json
    prod.jsonfromsettings_manager.managerimportSettingsManagersm=SettingsManager(environment='test',filetype='json'settings_dir='/path/to/project/root/config/settings')sm.load()# view settings dictionarysm.settings()# { 'secret-key' : 'h390h2g3', ... }YAML Config FilesImagine you are working on a project with the following structure:myapp/
  app.py
config/
  settings/
    test.yaml
    dev.yaml
    prod.yamlYour yaml files can have.ymlor.yamlfile extensions.fromsettings_manager.managerimportSettingsManagersm=SettingsManager(environment='test',filetype='yaml'settings_dir='/path/to/project/root/config/settings')sm.load()# view settings dictionarysm.settings()# { 'secret-key' : 'h390h2g3', ... }Python Config FilesImagine you are working on a project with the following structure:myapp/
  app.py
config/
  settings/
    test.py
    dev.py
    prod.pyfromsettings_manager.managerimportSettingsManagersm=SettingsManager(environment='test',filetype='python'settings_dir='/path/to/project/root/config/settings'python_settings_module='config.settings')sm.load()# view settings dictionarysm.settings()# { 'secret-key' : 'h390h2g3', ... }Todos:Add deep merge ability
Package: settings-master
This Is Package for fast use SETTINGS.ExampleSTRUCTUREsettings
|
-- db.py
|
-- api.py
|
-- __init__.pysettings/db.pyDB_NAME="name"DB_PASSWORD="password"settings/api.pyAPI_TOKEN="dekejfire"settings/__init__.pyfromsettings_masterimportDirectorySettings,settingsasthissettings=DirectorySettings(this)Now we can use this:fromsettings_master.settingsimportsettingsassertsettings.DB_NAME=="name"assertsettings.DB_PASWORD=="password"assertsettings.API_TOKEN=="dekejfire"DEVLINUX / MAC Xpython3setup.pysdistupload
twineuploaddist/*WINDOWSpythonsetup.pysdistupload
twineuploaddist/*
Package: settings-parser
Load and parse user settingsInstallationPython 3.5 or 3.6 is required. InstallingAnacondais recommended; it
works with Windows (64/32 bits), Linux (64/32 bits) and Mac (64 bits).After installing Anaconda execute the following commands at the command
prompt (cmd.exe for Windows, shell for Linux and Mac):conda config --add channels conda-forge
conda config --add channels pedvide
conda install settings_parser(The first two commands add packages repositories with up-to-date
versions of all needed packages.)orpip install settings_parserThat will download and install all necessary files.UpdateIf you installed it using conda, update with:conda update settings_parserIf you installed it with pip, update with:pip install -U settings_parserFeaturesDocumentationTODOBugs/RequestsPlease use theGitHub issue
trackerto submit bugs or
request features.LicenseCopyright Pedro Villanueva Delgado, 2017.Distributed under the terms of theMITlicense,
settings_parser is free and open source software.
Package: settingspy
This module provides aspyobject that resolves an attribute by
searching sequentially in following places:manually set settingssettings cataloguser-provided settings modulemanually set fallbacksExamples:Manally set settings:from settingspy import spy
spy[‘this_is_int’] = 123
spy[‘this_is_str’] = ‘string’
print(spy.this_is_int, spy.this_is_str)Settings catalogInside the directory specified by the SETTINGSPY_CATALOG environment
variable, a file namedsomethingmay exist with the desired value.
File contents are restricted to booleans, integers, floats, strings.
They are parsed as if eval()ed, so strings should be wrapped in
parentheses.$ echo 123 > “$SETTINGSPY_CATALOG/this_is_int”
$ echo “‘string’” > “$SETTINGSPY_CATALOG/this_is_str”User provided settings modulein file mysettings.py:
this_is_int = 123
this_is_str = ‘string’import os; os.environ[‘SETTINGSPY_MODULE’] = ‘mysettings’
from settingspy import spy; print(spy.this_is_int, spy.this_is_str)Manually set fallbacksIn case a setting attribute isn’t defined anywhere else.from settingspy import spy
spy.setfallback(‘this_is_int’, 123)
spy.setfallback(‘this_is_str’, ‘string’)For more details see the source code athttps://github.com/ydm/settingspy
Package: settings-read-write
settingsDescriptionManage (read/ write) settings file in different formats (eg. JAML, JSON, ...)Suppeorted standardsjsonyaml/ ymlRequiredpython3pipDirectories structure.githubISSUE_TEMPLATEbug_report.mdfeature-request.mdworkflowspypi-on-push.ymlpypi-on-release.ymlpython-test.ymlsettings__init__.pytest-settings.pydocsLICENSEREADME.mdlogtrace.logrequirementsrequirements.txt.gitignoresetup.pyExecution examples# Import
from settings import settings

# Inizialize
mysettings = settings(file, format) # file = file path; format = one of "json", "yml", "yaml" (default "yaml")

# Read
mysettings.read()

# Write
mysettings.write(a_dictionary_with_your_settings)ChangelogVersion_01.03_2021-03-07Version_01.02_2021-02-22Version_01.01_2021-02-22Version_01.03_2021-03-07Added a needed requirementsVersion_01.02_2021-02-22Fixed a minor bugVersion_01.01_2021-02-22Initial versionMade by Castellani Davide
If you have any problem please contact me:help@castellanidavide.itIssue