code: 
  
  
  
  import textwrap
  
  import pyarrow as pa
  import pytest
  
  from datasets import Features, Image
  from datasets.packaged_modules.text.text import Text
  
  from ..utils import require_pil
  @pytest.fixture
  def 	UpperCamelCase			(     snake_case__ :					Any			)			->  Union[str, Any]:
     UpperCamelCase					:						Optional[int]					=			tmp_path / 'text.txt'
     UpperCamelCase					:						Dict					=			textwrap.dedent(
         '\\n        Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.\n        Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n        Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.\n        Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n\n        Second paragraph:\n        Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.\n        Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n        Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.\n        Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n        '			)
     with open(snake_case__ ,  'w' ,  encoding='utf-8'			) as f:
        f.write(snake_case__			)
     return str(snake_case__			)
  @pytest.fixture
  def 	UpperCamelCase			(     snake_case__ :					List[Any] ,  snake_case__ :					List[str]			)			->  str:
     UpperCamelCase					:						Optional[int]					=			tmp_path / 'text_with_image.txt'
     with open(snake_case__ ,  'w' ,  encoding='utf-8'			) as f:
        f.write(snake_case__			)
     return str(snake_case__			)
  @pytest.mark.parametrize('keep_linebreaks' ,  [True, False]			)
  def 	UpperCamelCase			(     snake_case__ :					Dict ,  snake_case__ :					int			)			->  Optional[int]:
     with open(snake_case__ ,  encoding='utf-8'			) as f:
        UpperCamelCase					:						str					=			f.read().splitlines(keepends=snake_case__			)
     UpperCamelCase					:						Optional[Any]					=			Text(keep_linebreaks=snake_case__ ,  encoding='utf-8'			)
     UpperCamelCase					:						Optional[Any]					=			text._generate_tables([[text_file]]			)
     UpperCamelCase					:						Union[str, Any]					=			pa.concat_tables([table for _, table in generator]			).to_pydict()['text']
     assert generated_content == expected_content
  @require_pil
  def 	UpperCamelCase			(     snake_case__ :					List[str]			)			->  Optional[Any]:
     with open(snake_case__ ,  encoding='utf-8'			) as f:
        UpperCamelCase					:						Any					=			f.read().splitlines()[0]
     UpperCamelCase					:						List[Any]					=			Text(encoding='utf-8' ,  features=Features({'image': Image()}			)			)
     UpperCamelCase					:						Optional[int]					=			text._generate_tables([[text_file_with_image]]			)
     UpperCamelCase					:						str					=			pa.concat_tables([table for _, table in generator]			)
     assert pa_table.schema.field('image'			).type == Image()()
     UpperCamelCase					:						int					=			pa_table.to_pydict()['image']
     assert generated_content == [{"path": image_file, "bytes": None}]
  
  
  @pytest.mark.parametrize('sample_by' ,  ['line', 'paragraph', 'document']			)
  def 	UpperCamelCase			(     snake_case__ :					Tuple ,  snake_case__ :					Optional[Any]			)			->  Union[str, Any]:
     with open(snake_case__ ,  encoding='utf-8'			) as f:
        UpperCamelCase					:						Optional[Any]					=			f.read()
     if sample_by == "line":
        UpperCamelCase					:						str					=			expected_content.splitlines()
     elif sample_by == "paragraph":
        UpperCamelCase					:						Dict					=			expected_content.split('\n\n'			)
     elif sample_by == "document":
        UpperCamelCase					:						Union[str, Any]					=			[expected_content]
     UpperCamelCase					:						Dict					=			Text(sample_by=snake_case__ ,  encoding='utf-8' ,  chunksize=100			)
     UpperCamelCase					:						List[Any]					=			text._generate_tables([[text_file]]			)
     UpperCamelCase					:						Union[str, Any]					=			pa.concat_tables([table for _, table in generator]			).to_pydict()['text']
     assert generated_content == expected_content
  
  
  
  
style_context: 
  
  
  
  from __future__ import annotations
  
  import random
  
  from matplotlib import animation
  from matplotlib import pyplot as plt
  
  # Frame rate of the animation
  __UpperCAmelCase      = 20
  
  # Time between time steps in seconds
  __UpperCAmelCase      = INTERVAL / 1_000
  
  
  
  class        lowerCAmelCase_	:
         def __init__(    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ = 1.0,    SCREAMING_SNAKE_CASE_ = 1.0,    SCREAMING_SNAKE_CASE_ = "blue",    )  ->	None:
            UpperCamelCase					:						int					=			position_x
            UpperCamelCase					:						List[Any]					=			position_y
            UpperCamelCase					:						Tuple					=			velocity_x
            UpperCamelCase					:						Optional[Any]					=			velocity_y
            UpperCamelCase					:						Optional[Any]					=			mass
            UpperCamelCase					:						Union[str, Any]					=			size
            UpperCamelCase					:						Any					=			color
         @property
         def       snake_case_ (    self )  ->	tuple[float, float]:
            return self.position_x, self.position_y
         @property
         def       snake_case_ (    self )  ->	tuple[float, float]:
            return self.velocity_x, self.velocity_y
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )  ->	None:
            self.velocity_x += force_x * delta_time
            self.velocity_y += force_y * delta_time
  
  
  
  
  
  
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_ )  ->	None:
            self.position_x += self.velocity_x * delta_time
            self.position_y += self.velocity_y * delta_time
  
  
  
  
  
  
  class        lowerCAmelCase_	:
         def __init__(    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ = 1.0,    SCREAMING_SNAKE_CASE_ = 1.0,    SCREAMING_SNAKE_CASE_ = 0.0,    )  ->	None:
            UpperCamelCase					:						Tuple					=			bodies
            UpperCamelCase					:						Tuple					=			gravitation_constant
            UpperCamelCase					:						Any					=			time_factor
            UpperCamelCase					:						Any					=			softening_factor
         def __len__(    self )  ->	int:
            return len(self.bodies )
  
  
  
  
  
  
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_ )  ->	None:
            for bodya in self.bodies:
               UpperCamelCase					:						Optional[Any]					=			0.0
               UpperCamelCase					:						str					=			0.0
               for bodya in self.bodies:
                  if bodya != bodya:
                     UpperCamelCase					:						List[str]					=			bodya.position_x - bodya.position_x
                     UpperCamelCase					:						Union[str, Any]					=			bodya.position_y - bodya.position_y
  
                     # Calculation of the distance using Pythagoras's theorem
                     # Extra factor due to the softening technique
                     UpperCamelCase					:						Dict					=			(dif_x**2 + dif_y**2 + self.softening_factor) ** (
                         1 / 2
                     )
  
                     # Newton's law of universal gravitation.
                     force_x += (
                         self.gravitation_constant * bodya.mass * dif_x / distance**3
                     )
                     force_y += (
                         self.gravitation_constant * bodya.mass * dif_y / distance**3
                     )
  
              # Update the body's velocity once all the force components have been added
               bodya.update_velocity(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    delta_time * self.time_factor )
  
            # Update the positions only after all the velocities have been updated
            for body in self.bodies:
               body.update_position(delta_time * self.time_factor )
  
  
  
  
  
  
  def 	UpperCamelCase			(     snake_case__ :					BodySystem ,  snake_case__ :					float ,  snake_case__ :					list[plt.Circle]			)			->  None:
     body_system.update_system(snake_case__			)
  
     # Update the positions of the patches
     for patch, body in zip(snake_case__ ,  body_system.bodies			):
        UpperCamelCase					:						List[str]					=			(body.position_x, body.position_y)
  def 	UpperCamelCase			(     snake_case__ :					str ,  snake_case__ :					BodySystem ,  snake_case__ :					float = -1 ,  snake_case__ :					float = 1 ,  snake_case__ :					float = -1 ,  snake_case__ :					float = 1 ,  )			->  None:
     UpperCamelCase					:						Dict					=			plt.figure()
     fig.canvas.set_window_title(snake_case__			)
     UpperCamelCase					:						Any					=			plt.axes(
         xlim=(x_start, x_end) ,  ylim=(y_start, y_end)			)  # Set section to be plotted
     plt.gca().set_aspect('equal'			)  # Fix aspect ratio
  
     # Each body is drawn as a patch by the plt-function
     UpperCamelCase					:						List[Any]					=			[
         plt.Circle((body.position_x, body.position_y) ,  body.size ,  fc=body.color			)
         for body in body_system.bodies
     ]
  
     for patch in patches:
        ax.add_patch(snake_case__			)
  
     # Function called at each step of the animation
     def update(snake_case__ :					int			) -> list[plt.Circle]:
        update_step(snake_case__ ,  snake_case__ ,  snake_case__			)
        return patches
  
     UpperCamelCase					:						Dict					=			animation.FuncAnimation(  # noqa: F841
         snake_case__ ,  snake_case__ ,  interval=snake_case__ ,  blit=snake_case__			)
  
     plt.show()
  def 	UpperCamelCase			(     )			->  BodySystem:
     UpperCamelCase					:						str					=			0.9700436
     UpperCamelCase					:						Optional[Any]					=			-0.24308753
     UpperCamelCase					:						Optional[int]					=			0.466203685
     UpperCamelCase					:						int					=			0.43236573
  
     UpperCamelCase					:						int					=			[
         Body(snake_case__ ,  snake_case__ ,  snake_case__ ,  snake_case__ ,  size=0.2 ,  color='red'			),
         Body(-position_x ,  -position_y ,  snake_case__ ,  snake_case__ ,  size=0.2 ,  color='green'			),
         Body(0 ,  0 ,  -2 * velocity_x ,  -2 * velocity_y ,  size=0.2 ,  color='blue'			),
     ]
     return BodySystem(snake_case__ ,  time_factor=3			)
  def 	UpperCamelCase			(     )			->  BodySystem:
     UpperCamelCase					:						str					=			7.3_476E22
     UpperCamelCase					:						str					=			5.972E24
     UpperCamelCase					:						Union[str, Any]					=			1022
     UpperCamelCase					:						Optional[Any]					=			384399000
     UpperCamelCase					:						str					=			6.674E-11
  
     # Calculation of the respective velocities so that total impulse is zero,
     # i.e. the two bodies together don't move
     UpperCamelCase					:						int					=			earth_mass * velocity_dif / (earth_mass + moon_mass)
     UpperCamelCase					:						str					=			moon_velocity - velocity_dif
  
     UpperCamelCase					:						Optional[int]					=			Body(-earth_moon_distance ,  0 ,  0 ,  snake_case__ ,  snake_case__ ,  10000000 ,  'grey'			)
     UpperCamelCase					:						Dict					=			Body(0 ,  0 ,  0 ,  snake_case__ ,  snake_case__ ,  50000000 ,  'blue'			)
     return BodySystem([earth, moon] ,  snake_case__ ,  time_factor=1000000			)
  def 	UpperCamelCase			(     )			->  BodySystem:
     UpperCamelCase					:						int					=			[]
     for _ in range(10			):
        UpperCamelCase					:						Optional[int]					=			random.uniform(-0.5 ,  0.5			)
        UpperCamelCase					:						Union[str, Any]					=			random.uniform(-0.5 ,  0.5			)
  
        # Bodies are created pairwise with opposite velocities so that the
        # total impulse remains zero
        bodies.append(
            Body(
                random.uniform(-0.5 ,  0.5			) ,  random.uniform(-0.5 ,  0.5			) ,  snake_case__ ,  snake_case__ ,  size=0.05 ,  )			)
        bodies.append(
            Body(
                random.uniform(-0.5 ,  0.5			) ,  random.uniform(-0.5 ,  0.5			) ,  -velocity_x ,  -velocity_y ,  size=0.05 ,  )			)
     return BodySystem(snake_case__ ,  0.01 ,  10 ,  0.1			)
  
  
  if __name__ == "__main__":
      plot('''Figure-8 solution to the 3-body-problem''', example_a(), -2, 2, -2, 2)
      plot(
          '''Moon\'s orbit around the earth''',
          example_a(),
          -430_000_000,
          430_000_000,
          -430_000_000,
          430_000_000,
      )
      plot('''Random system with many bodies''', example_a(), -1.5, 1.5, -1.5, 1.5)
  
  
  
  