Saravanan666/pypi-org huggingface dataset:
Package: dynamic-plugins
Python Dynamic PluginsIn a nutshellPython Dynamic pluginsis a small library for manage Python plugins dynamically.Python Dynamic PluginsQuickstartPip utilsDynamic library loadingInstallDynamic module load usageLoad symbolsPip utilsList installed packagesInstall a package from PypiInstall a package from local folderLicenseContributionsQuickstartThis library has two main parts:Pip utilsDynamic library loadingPip utilsThis module provides some utilities for pip from Python.Dynamic library loadingThis library load, following some contrains, Python packages and load specific symbols from them. This is: functions, class definitions, variables, etcThe main idea of the project is to be able to create a plugin system which is easy to use and easy to maintain.Install>pipinstalldynamic-pluginsDynamic module load usageFor this example we'll use the demo packagedemo_modulethat you can find in thedemo_pluginsfolder.First you need to install the demo package>cddemo_plugins/demo_module
>pipinstall.-ULoad symbolsIn this example we'll load thehello_world()function dynamically from thedemo_modulepackage.fromdynamic_pluginsimportget_extensionsdefmain():forpackage_name,package_contentinget_extensions("demo-",sub_package="setup",symbols="hello_world").items():print(package_name)print(package_content["module_object"])forfninpackage_content["symbols"]:print(fn())if__name__=='__main__':main()Pip utilsList installed packagesfromdynamic_pluginsimportlist_installed_packagesdefmain():forpackage_name,package_versioninlist_installed_packages().items():print(f"{package_name}{package_version}")if__name__=='__main__':main()Install a package from Pypifromdynamic_pluginsimportinstall_library_from_pypidefmain():install_library_from_pypi("requests")if__name__=='__main__':main()Install a package from local folderfromdynamic_pluginsimportinstall_library_from_pathdefmain():install_library_from_path("/path/to/package")if__name__=='__main__':main()LicenseDictionary Search is Open Source and available under theMIT.ContributionsContributions are very welcome. SeeCONTRIBUTING.mdor skim existing tickets to see where you could help out.
Package: dynamic-pong
Dynamic PongDynamic Pong is a modern rendition of the classic arcade game Pong, crafted with Python using the Pygame library. It offers an engaging and interactive gaming experience, featuring responsive paddle controls and dynamic game speed adjustments. This project is an excellent showcase of Python programming skills, game design, and software development principles.FeaturesAdaptive Gameplay: The game's difficulty increases as you progress, offering a challenging and engaging experience.Collision Detection: Implements collision logic for paddles and game boundaries.Score Tracking: Real-time score display for both the player and the computer-controlled opponent.Customizability: Adjustable game window size and element proportions to fit various screens.InstallationTo play Dynamic Pong, you need to have Python and Pygame installed on your system.Install Python: Download and install Python frompython.org.Install Pygame: Runpip install pygamein your command line.Download the Game: Clone or download this repository to your local machine.How to PlayNavigate to the directory containing the game files.Run the scriptpython dynamic_pong.py.Control the left paddle using theUpandDownarrow keys or theWandSkeys.The game continues indefinitely until manually exited.Code Examples# Creating a block representing a paddleblock=Block("white",20,100,50,300)# Initializing a player paddleplayer=Player("white",20,140,5)# Handling a ball collision with the top edge of the screenball=Ball("white",30,30,paddle_group)ball.rect.top=-5ball.speed_y=-5ball.collisions()ContributingContributions to Dynamic Pong are welcome! If you have suggestions for improvements or encounter any issues, please feel free to open an issue or submit a pull request.LicenseThis project is licensed under the MIT License - see theLICENSEfile for details.About the AuthorAdamya Singh - Aspiring software developer with a passion for game development and Python programming. Feel free to connect with me onLinkedIn.
Package: dynamic-programming
Library for Studying Dynamic ProgrammingDP is suitable for a particular kind of problem (computation) structure: the subproblems are highly overlapping (usually with exponential time complexity, like 2^n) and the recurrence relation can be clearly defined.In this library, I provide implementations of two major DP approaches – (1) top-down (recursion + memoization); (2) bottom-up (tabulation) – for some well-known DP problems, including:Fibonacci_NumbersHouse_RobberMin_Cost_Climbing_StairsMaximum_SubarrayBest_Time_to_Buy_and_Sell_StockCoin_ChangeWord_BreakDecode_WaysInstallationpip install dynamic-programmingSample Usage>>> from DP import Fibonacci_Numbers as fib
>>> F = fib()
>>> F.explanation() # this will show the code and some explanations
>>> F.top_down(n = 10)
55
>>> F.bottom_up(n = 10)
55>>> from DP import House_Robber as robber
>>> r = robber()
>>> r.explanation() # this will show the code and some explanations
>>> r.top_down(nums = [3, 10, 3, 1, 2, 4, 10, 2, 44, 98])
120
>>> r.bottom_up(nums = [3, 10, 3, 1, 2, 4, 10, 2, 44, 98])
120>>> from DP import Min_Cost_Climbing_Stairs as climb
>>> c = climb()
>>> c.explanation() # this will show the code and some explanations
>>> c.top_down(cost = [3, 10, 3, 1, 2, 4, 10, 2, 44, 98])
57
>>> c.bottom_up(cost = [3, 10, 3, 1, 2, 4, 10, 2, 44, 98])
57>>> from DP import Maximum_Subarray as maxsub
>>> m = maxsub()
>>> m.explanation() # this will show the code and some explanations
>>> m.top_down(nums=[-2, 1, -3, 4, -1, 2, 1, -5, 4, 9, -2, 10, 15, -3, -4])
[4, -1, 2, 1, -5, 4, 9, -2, 10, 15] has the largest sum = 37.
>>> m.bottom_up(nums=[-2, 1, -3, 4, -1, 2, 1, -5, 4, 9, -2, 10, 15, -3, -4])
[4, -1, 2, 1, -5, 4, 9, -2, 10, 15] has the largest sum = 37.>>> from DP import Best_Time_to_Buy_and_Sell_Stock as stock
>>> s = stock()
>>> s.explanation() # this will show the code and some explanations
>>> s.top_down(prices=[7, 1, 5, 3, 6, 4, 2, 10, 2, 3, 9, 1])
9
>>> s.bottom_up(prices=[7, 1, 5, 3, 6, 4, 2, 10, 2, 3, 9, 1])
9>>> from DP import Coin_Change as coin
>>> c = coin()
>>> c.explanation() # this will show the code and some explanations
>>> c.top_down(coins=[1, 5, 10, 25], amount=150)
6
>>> c.bottom_up(coins=[1, 5, 10, 25], amount=150)
6>>> from DP import Word_Break as wordbreak
>>> w = wordbreak()
>>> w.explanation() # this will show the code and some explanations
>>> w.top_down(s = "codingisfunpythonisgreat", wordDict = ["coding", "is", "fun", "python", "great"])
True
>>> w.bottom_up(s = "codingisfunpythonisgreat", wordDict = ["coding", "is", "fun", "python", "great"])
True>>> from DP import Decode_Ways as decode
>>> d = decode()
>>> d.explanation() # this will show the code and some explanations
>>> d.top_down(s = "12812823")
8
>>> d.bottom_up(s = "12812823")
8
Package: dynamicpy
DynamicPyA python module for dynamically interacting with objects to improve expandability.FeaturesDynamic LoaderDependency LibraryWidgetsDynamic LoaderTheDynamicLoaderclass allows for the dynamic import of modules and the scraping of their globals.To provide functionality with the scraped globals you must register a handler using theregister_handlermethod or thehandlerdecorator. Both methods take an optionalselectorparameter which is a predicate to determine wether the handler should be called.Example:fromdynamicpyimportDynamicLoaderloader=DynamicLoader()@loader.handler()defhandler(name:str,value:object):print(name)# Prints the name of every global importedloader.load_module("package.module")DynamicPy provides a handful of utility functions to traverse modules in the stack which can be useful for streamlining this process.Dependency LibraryTheDependencyLibraryclass allows you to create a library of objects which can then be injected into function parameters using type annotations.Dependencies are added using theaddmethod, only a single dependency per type can be added to the library. Dependencies can be retrived using square brackets. You can check if an object has been added to the library using theinoperator which can also be used to check if there are any dependencies of a certain type in the library.ExamplefromdynamicpyimportDependencyLibrarylibrary=DependencyLibrary()library.add("Hello World!")print(library[str])# Hello World!print(strinlibrary)# Trueprint("Hello World!"inlibrary)# Trueprint("Lorem Ipsum"inlibrary)# Falseprint(intinlibrary)# FalseTheDependencyLibraryclass also allows for dependencies to be injected into function parameters using theinjectmethod.ExamplefromdynamicpyimportDependencyLibrarylibrary=DependencyLibrary()library.add("Hello World!")definjected(message:str):print(message)# Hello World!library.inject(injected)WidgetsDynamicPy contains a helper for making 'widgets' with callback functions which are created using a decorator. Configure your widget by extending theBaseWidgetclass. Set the type parameter to configure the expected callback type.fromtypingimportAny,CallablefromdynamicpyimportBaseWidgetclassExampleWidget(BaseWidget[Callable[[str],Any]]):def__init__(self,callback:Callable[[str],Any],enabled:bool)->None:super().__init__(callback)DynamicPy will automatically generate aBaseWidget.decoratefunction based off your constructor.@ExampleWidget.decorate(enabled=False)defexample(message:str):print(message)This will add an attribute to the function, containing an instance of your widget. This can be easily retrieved using aDynamic Loader'sregister_widget_handlermethod orwidget_handlerdecorator.fromdynamicpyimportDynamicLoaderloader=DynamicLoader()@loader.widget_handler(ExampleWidget)defwidget_handler(widget:ExampleWidget):widget.callback("Hello World!")# prints "Hello World!"
Package: dynamic_pytables_where_condition
AboutPython library that dynamically constructs a PyTables where condition from the
supplied keyword arguments.This work is a part of the investigation within the research project[ON174027], supported by the Ministry for Science and Technology, Republic of
Serbia. This support is gratefully acknowledged.References[ON174027]“Computational Mechanics in Structural Engineering”InstallationTo install dynamic_pytables_where_condition run:$ pip install dynamic_pytables_where_conditionUsage examplesQuick start:>>> from dynamic_pytables_where_condition import construct_where_condition

>>> construct_where_condition()
''

>>> construct_where_condition(t_b_min=4.0, t_b_max=8.0, a_min=2000.0)
'(a >= 2000.0) & (t_b <= 8.0) & (t_b >= 4.0)'

>>> construct_where_condition(t_b_fix=4.0, t_b_max=None, a_min=None)
'(t_b == 4.0)'Please see thefsm_modal_analysissource code for more examples.ContributeIf you find any bugs, or wish to propose new featuresplease let us know.If you’d like to contribute, simply forkthe repository, commit your changes
and send a pull request. Make sure you add yourself toAUTHORS.
Package: dynamic-rename
dynamic_renameWith This Library  You can rename pyspark dataframe  column.
It will rename the columns name on a dynamic way.
only user need to provide the new renamed name for the columns
it will work only when you are doing work with Pyspark.Before call this module Your data frame have to be load sucessfuly.version0.0.3Authors@RANJIT_MAITYReales Date16-10-2022BadgesAbout AuthorI Am Ranjit From INDIA, a Certified Data scientist , Data Engineer by professional  with hands-on experience of more than 1year and 2months ,on ML> NLP> Data mining > Neural Networks > ModeL Deployment>ETL.
Give me raw data and I'll return you insights, problems to be rectified and enhancements to achieve the target. I am always on the lookout for new projects to work And
Am Always Happy â˜» To Play With DataLinks
Package: dynamic-rest
Dynamic RESTDynamic API extensions for Django REST FrameworkSeehttp://dynamic-rest.readthedocs.orgfor full documentation.OverviewDynamic REST (or DREST) extends the popularDjango REST
Framework(or DRF) with API
features that empower simple RESTful APIs with the flexibility of a
graph query language.DREST classes can be used as a drop-in replacement for DRF classes,
which offer the following features on top of the standard DRF kit:Linked relationshipsSideloaded relationshipsEmbedded relationshipsField inclusionsField exclusionsField-based filteringField-based sortingDirectory panel for your Browsable APIOptimizationsDREST was initially written to complementEmber
Data, but it can be used to provide
fast and flexible CRUD operations to any consumer that supports JSON
over HTTP.MaintainersAnthony LeontievSavinay NangaliaChristina D’AstolfoRequirementsPython (3.6, 3.7, 3.8)Django (2.2, 3.1, 3.2)Django REST Framework (3.11, 3.12, 3.13)
Package: dynamic-rest-bse
Dynamic RESTDynamic API extensions for Django REST FrameworkSeehttp://dynamic-rest.readthedocs.orgfor full documentation.OverviewDynamic REST (or DREST) extends the popularDjango REST
Framework(or DRF) with API
features that empower simple RESTful APIs with the flexibility of a
graph query language.DREST classes can be used as a drop-in replacement for DRF classes,
which offer the following features on top of the standard DRF kit:Linked relationshipsSide-loaded relationshipsEmbedded relationshipsField inclusionsField exclusionsField-based filteringField-based sortingDirectory panel for your Browsable APIOptimizationsDREST was initially written to complementEmber
Data, but it can be used to provide
fast and flexible CRUD operations to any consumer that supports JSON
over HTTP.MaintainersAnthony LeontievSavinay NangaliaChristina D’AstolfoRequirementsPython (3.9, 3.10, 3.11)Django (3.1, 3.2, 4.0, 4.1, 4.2)Django REST Framework (3.11, 3.12, 3.13, 3.14)
Package: dynamics
Intergation betweenpandasand MS Dynamics CE / CRM / CDSA Helper pip package forpandasinteraction with MS Dynamics instances.The code will try to clean up data available in MS Dynamics instance by casting to correct Python types and pushing it pandas'DataFrame.Reading entity data to dataframe:import dynamics


# Create a dataframe which will hold needed information
data = pandas.DataFrame()

data.dynamics.connect(
    'https://instance.crm4.dynamics.com', 
    'user@instance.onmicrosoft.com', 
    'password').entity("prefix_entity").read()


print(data)
Package: dynamic-scheduler
动态的带结果保存的定时任务管理器-DynamicScheduler安装pip install dynamic-scheduler介绍主要是结合 apscheduler 完成定时任务动态修改定时任务功能、增加定时任务结果缓存功能test运行下方demo重新config类，指定数据库schema尝试修改数据库表 cron中cron表达式验证定时任务是否修改查看apscheduler_jobs表任务结果demofromDynamicScheduler.dynamic_schedulerimportDynamicSchedulerProxyfromDynamicScheduler.scheduler_utilsimportSchedulerConfigimportdatetime,os,threadingdeftask():# print(datetime.datetime.now())# time.sleep(10)print('start time: ',datetime.datetime.now(),os.getpid(),threading.current_thread().name)returndatetime.datetime.now()classConfig(SchedulerConfig):DEFAULT_DB_URL='postgresql+psycopg2://postgres:123456@{your_ip}:5432/postgres?utf-8'SCHEDULER_SCHEMA='public's=DynamicSchedulerProxy(config_class=Config)s.add_job_with_default(func=task,cron_str='* * */5',id='task')s.clear_history()# 先清除缓存表s.add_result_listener()s.start()
Package: dynamics-client
Dynamics Web API Clientpipinstalldynamics-clientDocumentation:https://mrthearman.github.io/dynamics-client/Source Code:https://github.com/MrThearMan/dynamics-client/Contributing:https://github.com/MrThearMan/dynamics-client/blob/main/CONTRIBUTING.mdClient for making Web API request from a Microsoft Dynamics 365 Database.You should also read theDynamics Web API Reference Docs:Basic usage:fromdynamicsimportDynamicsClient,ftr# Init the client:client=DynamicsClient(...)### Example GET request:client.table="accounts"# Get only these columns for the account.client.select=["accountid","name"]# Filter to only the accounts that have been created on or after the# given ISO date string, AND that have 200 or more employees.client.filter=[ftr.on_or_after("createdon","2020-01-01T00:00:00Z"),ftr.ge("numberofemployees",200),]# Expand to the contacts (collection-values navigation property)# on the account that have 'gmail.com' in their email address 1 OR 2.# Get only the 'firstname', 'lastname' and 'mobilephone' columns for these contacts.# Also expand the primary contact (single-valued navigation property).# Get only the 'emailaddress1' column for the primary contact.client.expand={"contact_customer_accounts":{"select":["firstname","lastname","mobilephone"],"filter":{ftr.contains("emailaddress1","gmail.com"),ftr.contains("emailaddress2","gmail.com"),}},"primarycontactid":{"select":["emailaddress1"],},}result=client.get()print(result.data)# [#     {#         "accountid": ...,#         "name": ...,#         "contact_customer_accounts": [#             {#                 "contactid": ...,  # id field is always given#                 "firstname": ...,#                 "lastname": ...,#                 "mobilephone": ...#             },#             ...#         ],#         "primarycontactid": {#             "contactid": ...,#             "emailaddress1": ...#         }#     },#     ...# ]### Example POST request# IMPORTANT!!!client.reset_query()client.table="contacts"# Get only these columns from the created contactclient.select=["firstname","lastname","emailaddress1"]# The data to create the contact with. '@odata.bind' is used to link# the contact to the given navigation property.accountid=...data={"firstname":...,"lastname":...,"emailaddress1":...,"parentcustomerid_account@odata.bind":f"/accounts({accountid})"}result=client.post(data=data)print(result.data)# {#     "contactid": ...,#     "firstname": ...,#     "lastname": ...,#     "emailaddress1": ...# }### Example PATCH requestclient.reset_query()client.table="contacts"client.row_id=result["contactid"]data={"firstname":...,"lastname":...,}result=client.patch(data=data)print(result.data)# Return all rows on the updated contact,# since no select statement was given## {#     ...#     "contactid": ...,#     "firstname": ...,#     "lastname": ...,#     ...# }### Example DELETE requestclient.reset_query()client.table="contacts"client.row_id=result["contactid"]client.delete()
Package: dynamicscope
This module implements dynamic scope for Python: it allows Python code
to get and set variables defined anywhere in its call stack, searching
first its own local variables, then its caller’s local variables, and
so on, until it finds a variable with the desired name.It is strongly recommended to only use this module for education, fun
party tricks, and write-only throw-away code which no one will ever
need to reuse or maintain.VersioningThis library’s version numbers follow theSemVer 2.0.0
specification.Installationpip install dynamicscopeUsageImport:fromdynamicscopeimportDYNAMIC_SCOPETo get a variable namedxin the current dynamic scope:DYNAMIC_SCOPE.x(Note:dynamic scope starts withyourstack frame, not your caller’s
stack frame, so if you have a variable namedxin the local scope,DYNAMIC_SCOPE.xwill refer to thatx, not bypass it.)To overwrite a existing variable namedxin the current dynamic scope:DYNAMIC_SCOPE.x='foo'To delete a variable namedxfound in the current dynamic scope:delDYNAMIC_SCOPE.x(DANGER:reaching up from a lower scope to delete variables in
callers is a GOTO-level crime under international software law.)If a variable is not found in dynamic scope, anAttributeErroris raised:AttributeError: 'x' not found in dynamic scope(It is anAttributeErrorand not aNameErrorbecause dynamic scope
is accessed with attribute access - returning the standard error for
attribute access composes better with existing code and builtins likehasattr,getattr, anddelattr.)Getting and setting variables with dynamic scope is not always possible
in Python. Two errors, both subclasses ofRuntimeError, are defined
to help you detect when it cannot be done:If the stack cannot be inspected to find variables during either
a get, set, or delete: adynamicscope.ReadErroris raised.If the stack cannot be modified during a set or delete:
adynamicscope.WriteErroris raised.CautionMost languages do not have dynamic scope for really good reason.In a world where dynamic scope is used,your local variables are part
of your observable interface, and the only thing protecting two
pieces of code from trampling over or shadowing each others’ variables
is conventions about how things are named. For example:{{your modulename}}_foofor any variable that you intend for
your users to set or get through dynamic scope, and_{{yourmodulename}}_foofor any variable that you intend for
your code to privately set or get through dynamic scope.Detailsdynamicscopeworks by using Python’s stack frame inspection, specificallyinspect.currentframe()and thef_localsattribute offrame objects.
Package: dynamicscrapper
Dynamic ScrapperSTILL IN DEVELOPMENTThe Goal Of This Package:The goal of this package is being able toscrap any site givenandgather any datano matter they type/style of said site.This project was a huge part of understanding webscrapping in general.How to use:The package is equipped with aCLICK CLIto give the input needed to extract the data needed.Steps:First step is giving the link of the site you want scrapped. (it can be either a page that contains a bunch of links to click and extract data from inside every link or one single page that you want data extracted from).If the link you gave is of a page containing a bunch of links to get data from, write the class name of thecontaining the "a" tag that contains these links (in most cases these links always have the same class name)[LEAVE EMPTY IF IT'S A SINGLE PAGE EXTRACTION].Choose the type of pagination used in said page to be able to extract data from all pages:number: for sites with numbered paginationsee_more: for sites with a see more button that expands the rest of the informationnone: incase of a single page or a infinite scrollp ageWrite the class name of the pagination class used according to:number: write the class name of the button "next" or ">" that takes you to the next pagesee_more: write the class name of the see_more buttonnone: leave emptyChoosing the items to scrap
This step is gonna look like this:Choose a name for the itemChoose the type you want to use to extract said item:
- tag-name: using html tag names
- class-name: using class-names
- id: using id
- name: using name attribute
- link-text: by giving the text inside a "a" tagChoose the name of the type you specified before:
- tag-name : the tag name you want to extract from (h1, h2, a ...)
- class-name: the class name needed
- id: the id needed
- name: the name inside the attribute
- link-text: the text inside the "a" tagIFyou are trying to get the value inside an attribute of a tag, write the tag name   you want to get (for example you need img url inside an "img" tag, you write "src" to get the text inside the src)Choose Y or N to continue adding items to scrap or stop.## Tips for number 5:use tag-name when there is only one tag of that kind (h1..)class-name is the most used but make sure to take a unique name so you dont get other items by mistake.be carefull when using id as an id can change from page to page of the same element.
Package: dynamic-service
dynamic-serviceA framework for developing responsive, live and dynamic RESTService APIs with python.first of allspecifics:writen and owned by: Shahaf Frank-Shapirall the rights are saved for: Shahaf Frank-Shapirprogramming languages: python 3.9.12 (100%)before we startdescription:A framework for developing responsive, live and dynamic RESTService APIs with python.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