Saravanan666/pypi-org huggingface dataset:
Package: autoschedule
autoschedule by ChomtanaGenerate schedule, talks, speakers page automatically like official Pycon thailand 2019 website:https://th.pycon.orgSchedule Page:https://th.pycon.org/scheduleTalks Page:https://th.pycon.org/talksSpeakers Page:https://th.pycon.org/speakersThese three pages generated from one yaml file:CLICK HERE FOR YAML FILE EXAMPLE (talks2019.yaml)And these three pages are linked togetherGood for people who organizing conference event and don't want to code your website schedule, talks, speakers pageHow to useFor local file generation useBasic examplefromautoscheduleimportgenerategenerate("talks2019.yaml")Note: you need to changetalks2019.yamlto your correct yaml file pathCustom file namefromautoscheduleimportgenerategenerate("talks2019.yaml",schedule_page="./timetable.html",talks_page="./courses.html",speakers_page="./tutors.html")Note: you need to changetalks2019.yamlto your correct yaml file pathFor using in nikolaStep 1: Install ScheduleShortcode pluginsCopyScheduleShortcode.pyandScheduleShortcode.pluginfrom this repository to plugins/schedule folder in your nikola setupNote: if folder doesn't exists, create new oneStep 2: Use shortcode in your pagePaste:{{% schedule mode="schedule" file="../talks2019.yaml" talks_page="/talks" speakers_page="/speakers" schedule_page="/schedule %}}To your schedule page{{% schedule mode="talks" file="../talks2019.yaml" talks_page="/talks" speakers_page="/speakers" schedule_page="/schedule %}}To your talks page{{% schedule mode="speakers" file="../talks2019.yaml" talks_page="/talks" speakers_page="/speakers" schedule_page="/schedule %}}To your speakers pageNote: you need to change../talks2019.yamlto your correct yaml file pathExample of these step can be found inhere
Package: auto-screener
auto-screenerA software for automatically screening crypto exchanges for crypto pairs trading prices and rates.first of allspecifics:writen and owned by: Shahaf Frank-Shapirall the rights are saved for: Shahaf Frank-Shapirprogram version: 0.0.0programming languages: python 3.9.12 (100%)before we startdescription:visit the docs to learn more about this project and how to develop with it.dependencies:opening:
As for this is a really complex program, which uses a lot of modules, there are required dependencies needed
in order to run the program. keep in mined the program was writen in python 3.9, so any python version lower
than 3.8 might not work properly. Moreover, built-in python modules are being used, so keep that in mind.install app dependencies by writing the "-r" option to install the requirements
writen in a file, and write the following line in the project directory:pip install -r requirements.txtrun a testrun from windows command line (inside the project directory)run with python by writing to the command line in the project directory:python test.py
Package: autoscrum
AutoScrumAutoScrum is a python script for automating the Scrum project planning process
using language models.Download Research PaperYou provide it with your product name, current customer situation and desired
customer situation and the script does the rest.AutoScrum is designed to assist users with the automatic generation of detailed
scrum plans using language models.AutoScrum also supports shortcut mode where a single language program is used to generate the next
most urgent task to bridge the gap between current and desired situation. The shortcut mode does not
create any user stories or features. Instead it simply iteratively creates a plan.By using AutoScrum, you can generate stories, features, goals, requirements,
tasks, acceptance criteria, and clarifications for your scrum planning.InstallingYou can install dependencies using pip:pip3 install autoscrumHow to UseFirst create a json file that contains your initial parameters. See tests/test-run.json for an
example.{"product":"Your product name","vision":"Your product vision","niche":"Your target customer niche","current_state":{"some_state":10"some_other_state":5},"desired_state":{"some_state":20"some_other_state":50},"plan":[],"requirements":[],"sprint_duration":"2 weeks","features":[],"stories":[],"avoid":[]}AutoScrum will fill this file with results.To use the AutoScrum script, follow these steps:Pass the JSON data file for your scrum plan as an argument using the-for--data-fileoption when you run the script.Example:autoscrum-fmy_scrum_data.json<command><params>Select the command you want to execute. The available commands are:stories,features,goals,clarify,acceptance,tasks,requirements,plan.Example:autoscrum-fmy_scrum_data.jsonstoriesUse-nor--countoption to define the number of items you want to generate for the selected command. The default count is 3 for most commands, and 1 for theplancommand.Example:autoscrum-fmy_scrum_data.jsonstories-n5CommandsHere are the available commands:stories: Generate user stories.features: Generate features.goals: Generate sprint goals.clarify: Generate clarification questions for your stories.acceptance: Generate acceptance criteria for your stories.tasks: Generate tasks for your stories.requirements: Generate project requirements.plan: Generate a shortcut plan.OutputThe script prints the existing items (if any) of the selected type (stories,
features, goals, etc.) before it generates and prints the new items. The new
items are automatically added to your JSON data file.NoteThis script is meant to assist with scrum planning, but the generated content
should be reviewed and approved by your scrum team before use. Always consider
your specific project needs when planning a sprint.
Package: autosegl3
L3 Auto-segmentation ToolTool for automatically segmenting muscle and fat tissue in CT images acquired at the 3rd vertebral levelThe AutoSegL3 tool allows a data manager to train a deep learning model that automatically segments
muscle and fat tissue in CT images taken at the 3rd vertebral (L3) level. To train the deep learning model
the tool needs a collection of L3 images and corresponding TAG files that contain the labels of each tissue
to be segmented. To run the trained model on previously unseen CT images the tool only needs a collection of
L3 images. The tool will then produce a mask for each L3 image that outlines the location of the muscle and
fat regions.For training, if default parameters are used, all the data manager has to do is point the tool to a directory
containing L3 images and corresponding TAG files. From this directory, an HDF5 file will be generated. During
this process the images and TAG files will be checked for certain characteristics like a common dimension of
512 by 512 pixels, pixels containing normalized Hounsfield units, etc. Any images that do pass this initial
quality check will be reported in a text file.For testing the training procedure, the tool also has to be pointed to a directory containing both L3 images
and TAG files. However, only the L3 images will be used for generating segmentations. The TAG files will be used
to evaluate the quality of the segmentations. This step will also produce a summary report containing some
performance metrics, e.g., Dice scores. Note that the testing phase is only meant to obtain realistic performance
metrics. To use the model for prediction, train it on all data you have (see next section).For model preparation, train it on all data you have. Generate a CSV database containing certain clinical scores
for each L3 image, e.g., SMRA, muscle index, SAT index and VAT index (what other scores can we think of?). This
database can then be used to visualize the spread of scores across all images in the training data. When a new
image is predicted you can also highlight its position within the spread of the training scores.For prediction, the tool has to be pointed to a directory containing only L3 images.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2021-02-04)First release on PyPI.
Package: auto-selenium
auto-seleniumAuto-Selenium is a Python tool to automate the download of Selenium Web Drivers and store the profile sessions for the following browsers:Google ChromeFirefoxOperaBraveEdge (only for Windows)It utilizes Selenium and MSEdge toolsQuickstart examplesInstallationpipinstallauto-seleniumSimple UsagefromautoseleniumimportDriverwithDriver('chrome',root='drivers')asdriver:driver.get('https://www.google.com/')# Selenium Webdriver command examplesdriver.find_elements_by_tag_name('div')driver.refresh()Downloads driver based on current version of the browser. When it is used as a context manager, the driver returns Selenium's WebDriver object.Download specific versions of each driverfromautoseleniumimportdownload_driver,get_versiondownload_driver('firefox',version='0.29.1',root='drivers')download_driver('opera','latest')cversion=get_version('brave','current')lversion=get_version('brave','latest')ifcversion<lversion:print('You should update your browser!')You can specify between 'current', 'latest' or input an specific version for a driver.Create your custom driverimportautoseleniumclassTwitterBot(autoselenium.Driver):_URL='https://twitter.com'def__init__(self,*args,**kwargs):super().__init__(*args,**kwargs)self.logged=Falsedeflogin_required(func):deflogged_checker(self,*args,**kwargs):ifnotself.logged:self.log()returnfunc(self,*args,**kwargs)returnlogged_checkerdeflog(self):self.logged=Truepass@login_requireddefscrape(self):passContributeWould you like to contribute to this project? Here are a few starters:Improve documentationAdd Testing examplesBug hunts and refactorAdditional features/ More integrationsPhantom JS supportImplement default browser functions for Mac
Package: autoself
autoself:  automagically add method definition boilerplateFirst, a disclaimer.  Explicit self is good.  Bytecode hacks are bad.Put them together and it's quite clear that THIS MODULE IS AN ABOMINATION!But, it's a neat excursion into python's lower levels and if you *really**really* want to save yourself some keystrokes (like, you're desperatelytrying to hack into the Death Star's security system to override the trashcompactor as its cold metal jaws slowly squeeze you to a purple paste) thenit can help you do that.  But, stop and consider Guido's proclamation onthe matter:Having self be explicit is a *good thing*. It makes the code clear byremoving ambiguity about how a variable resolves. It also makes thedifference between functions and methods small."Things that will Not Change in Python 3000":http://www.python.org/dev/peps/pep-3099/#core-languageThis module is not about making 'self' implicit.  It doesn't try to changethe way methods work, or make any semantic changes whatsoever.  It does onesimple thing: automatically adds the boilerplate code to make a function dothe "right thing" when called as a method.It provides a single function 'autoself'.  Given a function as argument,'autoself' will return an equivalent function with the necessary boilerplatein place to act as a method.  This will depend on the specifics of thefunction, and could mean:* Inserting 'self' as the zeroth argument* Inserting 'cls' as the zeroth argument, and wrapping with classmethod()* Wrapping with staticmethod() if 'self' and 'cls' are not used* Doing nothing, if it's not a proper function or is fine the way it isFor example, defining the method 'likes'  using:def likes(self,ham,eggs):print self, "likes", ham, "and", eggsIs equivalent to defining it in the following way:def likes(ham,eggs):print self, "likes", ham, "and", eggslikes = autoself(likes)Or neater, using the @autoself decorator.  Of course, this isn't going tosave you any typing!  'autoself' can also be applied to a class, and willautoselfify all functions in that class's dict:class HeapsLessTyping:def likes(ham,eggs):# This gets 'self' automatically added as zeroth argumentprint self, "likes", ham, "and", eggsdef hates(spam):# This becomes a classmethod, with 'cls' added as zeroth argumentprint "all", cls, "hate", spamdef meh(toast):# This becomes a staticmethodprint toast, "is boring"HeapsLessTyping = autoself(HeapsLessTyping)When it becomes available (Python 2.6?), it will be even more convenient touse this with the class decorator syntax.Want to save even more typing?  'autoself' can be used as a metaclass towork its magic on all classes defined in a module:__metaclass__ = autoselfclass LookNoSelf:def __init__(my,special,args):self.my = myself.special = specialself.args = argsclass FiveKeystrokesSaved:def __init__(this,works,great):self.this = thisself.works = worksself.great = greatcounter = 0def ClassMethodsSaveEvenMore():cls.counter += 1Using this style, you can see a net saving in keystrokes with five methoddefinitions or less!
Package: auto-self-params
auto_self_paramsA python package to automatically assign parameters to self. This enables
replacing code such as:classA:""" Typical Code. """def__init__(self,param1,param2,kwparam1=0,kwparam2=0):""" Create Example Class."""self.param1=param1self.param2=param2self.kwparam1=kwparam1self.kwparam2=kwparam2# etc.With code more like:fromauto_self_paramsimportauto_self_paramsclassA:""" Revised Code. """def__init__(self,param1,param2,kwparam1=0,kwparam2=0):""" Create Example Class."""auto_self_params.auto_self_params(locals())# Assign all parameters to self# etc.Onlyuse this package if you need the paramters passed to__init__to
produce matching names in self when called.You can,however, create a dictionary with locals and remove unwanted
paramters before passing it toauto_self_paramsso as to exclude unwanted
parameters.If you would like to use the:def __init__(self, *args, **kwargs):format then you may wish to use a pattern such as:fromauto_self_paramsimportauto_self_paramsclassA:""" Revised Code. """def__init__(self,*args,**kwargs):""" Create Example Class."""param_dict={'self':self,'args':args,**kwargs}auto_self_params.auto_self_params(param_dict)# Assign parameters to self# etc.
Package: autosemver
AutosemverThis small module provides an easy way to automatically manage the evrsion of
your python modules by extracting information directly from the version control
system (currently only git supported, patches welcome).Once installed (ex.pip install autosemver), adding a single line in yoursetup.pyfile is enough to start using it:setup(
    name='some-package',
    url='http://my.fancy/shrubbery',
    ...
    install_requires=['some_important_dep', 'autosemver'],
    ...
    setup_requires=['autosemver'],
    ...
    autosemver=True,
)That will use tags, commit messages (searches for lines likeSem-Ver:...and* Incompatible) to generate a version compatible with the semantic
versioning standard (https://semver.org/).Read the full documentation here:http://autosemver.readthedocs.io
Package: autosend
IntroductionThis is a tool that logs everything your program printing on the screen,
and sends you an email when the program is finished or terminated.UsageFirst, create ~/.autosend.yaml using the following
template and modify the configs.#  =========== autosend yaml template ============
# specify the email SMTP server
username: "username"
password: "password"
server: smtp.example.com
port: 25
tls: False
timeout: 15

# specify the email subject format, where: 
# {path} implies the work_dir running the python script,
# {curtime} implies the current date and time
# {status} implies the log type (may be running or complete) 
subject_format: "【符合保密要求，可在手机端查阅】{path}日志 [{curtime}] [{status}]"

# specify the email sender's and receivers' addresses
sender: "example@example.com"
receivers: 
- "example@example.com"

# send logs by email only if the program runs after the specific seconds
send_after_seconds: 3600

# send logs by email EVERY specific seconds if the program is keep running
send_periods: 86400

# whether send html format logs instead of plain text
html: TrueThen add the following line in your code:import autosendAfter the program is finished or after a specific time,
you will get an email like:【符合保密要求，可在手机端查阅】Python Scripts日志 [2023-05-14 13:45] [completed]
xx send to xx 2023-05-14 13:46:27

 start_time: 2023-05-14 13:45
last update: 2023-05-14 13:46
   work_dir: D:\Users\A\Documents\Python Scripts
       args: test.py
================= last 100 lines of the log =================
1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'date' is not defined
1684043182.6202037

1 attachments
Package: autosentiment
Automate sentiment analysis toolAuthor : Sazin Reshed SaminEmail :sazinsamin50@gmail.comautosentiment is an open source library that generates sentiment type(positive,negetive,neutral) pie char,percentage,number and ternary value for pandas dataframe text portion.- UsageFor analysis the seintiment type in positive,negetive or neutral- Setup in normal environment and command window:pip install autosentiment- Setup in jupyter notebook:!pip install autosentiment- Import library :import autosentiment as at- The library is pandas dataframe dependent.Have to get dataframe('text columns') and give to command.
Like df['text]Features- sentiment type pie chart :at.pie()- sentiment type amount :Get the sentiment type(postive,negetive,neutral numbers)at.number()- sentiment percentage :Get the percentage of sentiment typeat.percentage()at.ternary_analysisGet the type of all text, here -1:negetive, 0:neutral, 1:positiveat.ternary_analysis()- An example usages>>import autosentiment as at

>>import pandas as pd

>>df=pd.read_csv("/home/samin/anaconda3/dataset_2.csv")

>>percent=at.percentage(df['text'])

>>print(percent)
>>Positve : 33.31 %, Negetive 20.96 %, Neutral : 45.72 %

>>number=at.number(df['text'])

>>print(number)
>>{'positive  ': 1087, 'negetive': 684, 'neutral': 1492}

>>ana=at.analysis_ternary(df['text'])

>>print(ana)
>>[-1, 1, 0.0, 0.0, 0.0, 0.0,.......,1]

>>at.pie(df['text'])For any bug, please notify in my email :sazinsamin50@gmail.com
Package: autoserver
AutoServerAutoServer is a python library for making quick web UIs, it was originally made for HackEd 2023.ExamplefromautoserverimportAutoServerapp=AutoServer()@app.addfuncdefTaxCalc(province:str,cost:float,taxrate:int):"""Computes the amount of tax on an item given the tax rate:param province: The name of the province:param cost: The cost of the item expressed in dollars:param taxrate: The tax rate expressed as a percentage:return:"""tax=cost*float(taxrate)/100output=f"The tax in{province}for an item worth ${cost}is{tax}."output+=f"The total cost is ${cost+tax}."returnoutput@app.addfuncdefTargetPrice(province:str,targetcost:float,taxrate:int):targetRatio=1.0+float(taxrate)/100output=f"To have a final cost of ${targetcost}in{province},"output+=f"the pretax price should be ${targetcost/targetRatio}"returnoutputapp.run()
Package: autoset-pwd
https://app.codecov.io/gh/libranet/autoset-pwdautoset-pwdAutomatically add the $PWD-directory to thePWD_DIR-environment variable
viasitecustomize-entrypoint.How does it work?We register theautoset_pdw.entrypoint()-function to thesitecustomize-module that is installed by thesitecustomize-entrypoints-package.The registered function will look upos.getcwd()in your current working directory and
set it asPWD_DIR-environment variable.InstallationInstall via pip:>bin/pipinstallautoset-pwdOr add to your poetry-based project:>poetryaddautoset-pwdValidate & UsageAfter installing this package there is nothing left to do explicitly.
We can validate that the plugin work correctly by starting a python-session and checking thePWD_DIR-environment-variable:>bin/python>>>importos>>>print(os.getcwd())"<path-to-your-current-dir>"print(os.getenv("PwD_DIR"))
""Registered sitecustomize-entrypointTheautoset_pwd-function is registered as asitecustomize-entrypoint in our pyproject.toml_:[tool.poetry.plugins][tool.poetry.plugins."sitecustomize"]autoset_pwd="autoset_pwd:entrypoint"Sitecustomize and all its registered entrypoints will be executed at the start ofeverypython-process.
For more information, please seesitecustomize-entrypointsCompatibilityautoset-pwdworks on Python 3.8+, including PyPy3. Tested until Python 3.11,Notable dependenciessitecustomize-entrypoints
Package: autosetup-py
[Because every time I start preparing my projects for PyPI “deployment” I get upset.]setup.py (and relative files such as MANIFEST.in and setup.cfg) is not simple for the first (second, third) time.This project aims to provide asimplebootstrap for setup.py and other files on common structure (namedly MANIFEST.in, README.rst, LICENSE, requirements.txt and setup.cfg). Again, it’s a simple bootsrap. Take a look at some examples of generated outputhereInstallation:pipinstallautosetup-pyUsage:As a python method (with prompts)fromautosetup.mainimportmainmain()# Your project data will be promptedAs a python method (with parameters)fromautosetup.mainimportmainmain(module_name='potato',name='potato',version='0.0.1',author_name='Filipe Waitman',author_email='filwaitman@gmail.com',cvs_url='http://github.com/filwaitman/potato',tests_module='tests',requirements='requirements.txt',readme='README.rst',license='MIT',)As a CLI (with prompts)autosetup-py# Your project data will be promptedAs a CLI (with parameters)autosetup-py--module=potato--author_name="Filipe Waitman"--author_email=filwaitman@gmail.com--cvs_url="http://github.com/filwaitman/potato"--license=GPL3--use-defaultsNOTE: Seeautosetup-py --helpfor more options and documentationContributeDid you think in some interesting feature, or have you found a bug? Please let me know!Of course you can also download the project and send me somepull requests.You can send your suggestions byopening issues.You can contact me directly as well. Take a look at my contact information athttp://filwaitman.github.io/(email is preferred rather than mobile phone).
Package: autosign
AutosignAdd your signature to your files.Installationautosign can be installed using pip:pip install autosignUninstallingautosign can be uninstalled using pip:pip uninstall autosignDependenciesautosign is based on Python 2.7.DocumentationSigning filesautosign can be used for signing files:autosign signfile target [options]Run the following command, for various options:autosign --helpRemoving sign from filesautosign provides a utility,remsignfor removing sign from signed files:remsign target [options]Run the following command, for various options:remsign --helpChecking a packageautosign provides a utility,listsignfor collecting statistics:listsign target [options]Run the following command, for various options:listsign --helpSignrcAutosign utilizes signrc to sign, remove and list signed/un-signed files. The meaning of options is as follows.exttells the utilities to look for files with only that extensionStartdefines the starting character sequence of a signaturelinedefines the character sequence with whice every line(except start and end) should start of a valid signatureenddefines the ending character sequence of a signatureblank(boolean) allows/forbids usage of blank line before start or after end of a signatureallowdefines a special regular expression. Matching to which a line can be allowed before the start of a signature.Examples can be seen in examples directory. All the python files in this package have been signed usingexamples/templates/template1.txtusingexamples/signrc/signrc_py.–init option can be used for generating a very basic signrcAll the utilities look for.signrcfirst in cwd, then in home directory by default.BugsFor filing bugs raise an issue athttps://github.com/leosartaj/autosign/issuesReleases1.0.0sign filesunsign signed filesDisplay signed filesDisplay unsigned fileschecks python files only1.1.0configurable signature syntax